Skip to main content
Version: 4.xx.xxSource Code

useForm

The @refinedev/react-hook-form adapter allows you to integrate the React Hook Form library with refine, enabling you to manage your forms in a headless manner. This adapter supports all of the features of both React Hook Form and refine's useForm hook, and you can use any of the React Hook Form examples as-is by copying and pasting them into your project."

tip

All the data related hooks(useTable, useForm, useList etc.) of refine can be given some common properties like resource, meta etc.

Please refer to General Concepts for more information.

Installation​

Install the @refinedev/react-hook-form library.

npm i @refinedev/react-hook-form

Basic Usage​

For more detailed usage examples please refer to the React Hook Form documentation.

We'll show the basic usage of useForm by adding an editing form.

pages/posts/edit.tsx
import { useSelect } from "@refinedev/core";
import { useForm } from "@refinedev/react-hook-form";

export const PostEdit: React.FC = () => {
const {
refineCore: { onFinish, formLoading, queryResult },
register,
handleSubmit,
resetField,
formState: { errors },
} = useForm();

const { options } = useSelect({
resource: "categories",
defaultValue: queryResult?.data?.data.category.id,
});

useEffect(() => {
resetField("category.id");
}, [options]);

return (
<form onSubmit={handleSubmit(onFinish)}>
<label>Title: </label>
<input {...register("title", { required: true })} />
{errors.title && <span>This field is required</span>}
<br />
<label>Status: </label>
<select {...register("status")}>
<option value="published">published</option>
<option value="draft">draft</option>
<option value="rejected">rejected</option>
</select>
<br />
<label>Category: </label>
<select
{...register("category.id", {
required: true,
})}
defaultValue={queryResult?.data?.data.category.id}
>
{options?.map((category) => (
<option key={category.value} value={category.value}>
{category.label}
</option>
))}
</select>
{errors.category && <span>This field is required</span>}
<br />
<label>Content: </label>
<br />
<textarea
{...register("content", { required: true })}
rows={10}
cols={50}
/>
{errors.content && <span>This field is required</span>}
<br />

{queryResult?.data?.data?.thumbnail && (
<>
<br />
<label>Image: </label>
<br />

<img
src={queryResult?.data?.data?.thumbnail}
width={200}
height={200}
/>
<br />
<br />
</>
)}

<input type="submit" value="Submit" />
{formLoading && <p>Loading</p>}
</form>
);
};
tip

If you want to show a form in a modal or drawer where necessary route params might not be there you can use the useModalForm.

Properties​

action​

useForm can handle edit, create and clone actions.

tip

By default, it determines the action from route. The action is inferred by matching the resource's action path with the current route.

It can be overridden by passing the action prop where it isn't possible to determine the action from the route (e.g. when using form in a modal or using a custom route).

action: "create" is used for creating a new record that didn't exist before.

useForm uses useCreate under the hood for mutations on create mode.

In the following example, we'll show how to use useForm with action: "create".

http://localhost:3000/posts/create
import { useForm } from "@refinedev/react-hook-form";

const PostCreatePage: React.FC = () => {
const {
refineCore: { onFinish, formLoading },
register,
handleSubmit,
formState: { errors },
} = useForm();

return (
<form onSubmit={handleSubmit(onFinish)}>
<label>Title: </label>
<input {...register("title", { required: true })} />
{errors.title && <span>This field is required</span>}
<br />
<label>Status: </label>
<select {...register("status")}>
<option value="published">published</option>
<option value="draft">draft</option>
<option value="rejected">rejected</option>
</select>
<br />
<label>Content: </label>
<br />
<textarea
{...register("content", { required: true })}
rows={10}
cols={50}
/>
{errors.content && <span>This field is required</span>}
<br />
<br />
<input type="submit" disabled={formLoading} value="Submit" />
{formLoading && <p>Loading</p>}
</form>
);
};

resource​

Default: It reads the resource value from the current URL.

It will be passed to the dataProvider's method as a params. This parameter is usually used to as a API endpoint path. It all depends on how to handle the resource in your dataProvider. See the creating a data provider section for an example of how resource are handled.

useForm({
refineCoreProps: {
resource: "categories",
},
});
caution

If the resource is passed, the id from the current URL will be ignored because it may belong to a different resource. To retrieve the id value from the current URL, use the useParsed hook and pass the id value to the useForm hook.

import { useForm } from "@refinedev/react-hook-form";
import { useParsed } from "@refinedev/core";

const { id } = useParsed();

useForm({
refineCoreProps: {
resource: "custom-resource",
id,
},
});

Or you can use the setId function to set the id value.

import { useForm } from "@refinedev/react-hook-form";

const {
refineCore: { setId },
} = useForm({
refineCoreProps: {
resource: "custom-resource",
},
});

setId("123");

id​

id is used for determining the record to edit or clone. By default, it uses the id from the route. It can be changed with the setId function or id property.

It is usefull when you want to edit or clone a resource from a different page.

Note: id is required when action: "edit" or action: "clone".

useForm({
refineCoreProps: {
action: "edit", // or clone
resource: "categories",
id: 1, // <BASE_URL_FROM_DATA_PROVIDER>/categories/1
},
});

redirect​

redirect is used for determining the page to redirect after the form is submitted. By default, it uses the list. It can be changed with the redirect property.

It can be set to "show" | "edit" | "list" | "create" or false to prevent the page from redirecting to the list page after the form is submitted.

useForm({
refineCoreProps: {
redirect: false,
},
});

onMutationSuccess​

It's a callback function that will be called after the mutation is successful.

It receives the following parameters:

  • data: Returned value from useCreate or useUpdate depending on the action.
  • variables: The variables passed to the mutation.
  • context: react-query context.
useForm({
refineCoreProps: {
onMutationSuccess: (data, variables, context) => {
console.log({ data, variables, context });
},
},
});

onMutationError​

It's a callback function that will be called after the mutation is failed.

It receives the following parameters:

  • data: Returned value from useCreate or useUpdate depending on the action.
  • variables: The variables passed to the mutation.
  • context: react-query context.
useForm({
refineCoreProps: {
onMutationError: (data, variables, context) => {
console.log({ data, variables, context });
},
},
});

invalidates​

You can use it to manage the invalidations that will occur at the end of the mutation.

By default it's invalidates following queries from the current resource:

  • on create or clone mode: "list" and "many"
  • on edit mode: "list", "many" and "detail"
useForm({
refineCoreProps: {
invalidates: ["list", "many", "detail"],
},
});

dataProviderName​

If there is more than one dataProvider, you should use the dataProviderName that you will use. It is useful when you want to use a different dataProvider for a specific resource.

tip

If you want to use a different dataProvider on all resource pages, you can use the dataProvider prop of the <Refine> component.

useForm({
refineCoreProps: {
dataProviderName: "second-data-provider",
},
});

mutationMode​

Mutation mode determines which mode the mutation runs with. Mutations can run under three different modes: pessimistic, optimistic and undoable. Default mode is pessimistic. Each mode corresponds to a different type of user experience.

For more information about mutation modes, please check Mutation Mode documentation page.

useForm({
refineCoreProps: {
mutationMode: "undoable", // "pessimistic" | "optimistic" | "undoable",
},
});

successNotification​

NotificationProvider is required for this prop to work.

After form is submitted successfully, useForm will call open function from NotificationProvider to show a success notification. With this prop, you can customize the success notification.

useForm({
refineCoreProps: {
successNotification: (data, values, resource) => {
return {
message: `Post Successfully created with ${data.title}`,
description: "Success with no errors",
type: "success",
};
},
},
});

errorNotification​

NotificationProvider is required for this prop to work.

After form is submit is failed, refine will show a error notification. With this prop, you can customize the error notification.

useForm({
refineCoreProps: {
action: "create",
resource: "post",
errorNotification: (data, values, resource) => {
return {
message: `Something went wrong when deleting ${data.id}`,
description: "Error",
type: "error",
};
},
},
});
Default values
{
"message": "Error when updating <resource-name> (status code: ${err.statusCode})" or "Error when creating <resource-name> (status code: ${err.statusCode})",
"description": "Error",
"type": "error",
}

meta​

meta is a special property that can be used to pass additional information to data provider methods for the following purposes:

  • Customizing the data provider methods for specific use cases.
  • Generating GraphQL queries using plain JavaScript Objects (JSON).
  • Providing additional parameters to the redirection path after the form is submitted.

Refer to the meta section of the General Concepts documentation for more information β†’

In the following example, we pass the headers property in the meta object to the create method. With similar logic, you can pass any properties to specifically handle the data provider methods.

useForm({
refineCoreProps: {
meta: {
headers: { "x-meta-data": "true" },
},
},
});

const myDataProvider = {
//...
create: async ({ resource, variables, meta }) => {
const headers = meta?.headers ?? {};
const url = `${apiUrl}/${resource}`;

const { data } = await httpClient.post(url, variables, { headers });

return {
data,
};
},
//...
};

queryMeta​

In addition to the meta property, you can also pass the queryMeta property to the useForm hook. This property is used to pass additional information to the useOne hook that is used to fetch the data in the edit and clone modes. This is useful when you have to apply different values to the useOne hook from the useCreate or useUpdate hook mutations.

useForm({
queryMeta: {
querySpecificValue: "someValue",
},
});
tip

If you have overlapping properties in both meta and queryMeta, the queryMeta property will be used.

mutationMeta​

In addition to the meta property, you can also pass the mutationMeta property to the useForm hook. This property is used to pass additional information to the useCreate or useUpdate hook mutations. This is useful when you have to apply different values to the useCreate or useUpdate hooks from the useOne hook query.

useForm({
mutationMeta: {
mutationSpecificValue: "someValue",
},
});
tip

If you have overlapping properties in both meta and mutationMeta, the mutationMeta property will be used.

queryOptions​

Works only in action: "edit" or action: "clone" mode.

in edit or clone mode, refine uses useOne hook to fetch data. You can pass queryOptions options by passing queryOptions property.

useForm({
refineCoreProps: {
queryOptions: {
retry: 3,
},
},
});

createMutationOptions​

This option is only available when action: "create" or action: "clone".

In create or clone mode, refine uses useCreate hook to create data. You can pass mutationOptions by passing createMutationOptions property.

useForm({
refineCoreProps: {
queryOptions: {
retry: 3,
},
},
});

updateMutationOptions​

This option is only available when action: "edit".

In edit mode, refine uses useUpdate hook to update data. You can pass mutationOptions by passing updateMutationOptions property.

useForm({
refineCoreProps: {
queryOptions: {
retry: 3,
},
},
});

warnWhenUnsavedChanges​

Default: false

When it's true, Shows a warning when the user tries to leave the page with unsaved changes. It can be used to prevent the user from accidentally leaving the page.

It can be set globally in refine config.

useForm({
refineCoreProps: {
warnWhenUnsavedChanges: true,
},
});

liveMode​

Whether to update data automatically ("auto") or not ("manual") if a related live event is received. It can be used to update and show data in Realtime throughout your app. For more information about live mode, please check Live / Realtime page.

useForm({
refineCoreProps: {
liveMode: "auto",
},
});

onLiveEvent​

The callback function that is executed when new events from a subscription are arrived.

useForm({
refineCoreProps: {
onLiveEvent: (event) => {
console.log(event);
},
},
});

liveParams​

Params to pass to liveProvider's subscribe method.

Return Values​

queryResult​

If the action is set to "edit" or "clone" or if a resource with an id is provided, useForm will call useOne and set the returned values as the queryResult property.

const {
refineCore: { queryResult },
} = useForm();

const { data } = queryResult;

mutationResult​

When in "create" or "clone" mode, useForm will call useCreate. When in "edit" mode, it will call useUpdate and set the resulting values as the mutationResult property."

const {
refineCore: { mutationResult },
} = useForm();

const { data } = mutationResult;

setId​

useForm determine id from the router. If you want to change the id dynamically, you can use setId function.

const {
refineCore: { id, setId },
} = useForm();

const handleIdChange = (id: string) => {
setId(id);
};

return (
<div>
<input value={id} onChange={(e) => handleIdChange(e.target.value)} />
</div>
);

redirect​

"By default, after a successful mutation, useForm will redirect to the "list" page. To redirect to a different page, you can either use the redirect function to programmatically specify the destination, or set the redirect property in the hook's options.

In the following example we will redirect to the "show" page after a successful mutation.

const {
refineCore: { onFinish, redirect },
} = useForm();

// --

const handleSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
e.preventDefault();
const data = await onFinish(formValues);
redirect("show", data?.data?.id);
};

// --

onFinish​

onFinish is a function that is called when the form is submitted. It will call the appropriate mutation based on the action property. You can override the default behavior by passing an onFinish function in the hook's options.

For example you can change values before sending to the API.

saveButtonProps​

It contains all the props needed by the "submit" button within the form (disabled, onClick etc.). When saveButtonProps.onClick is called, it triggers handleSubmitfunction with onFinish. You can manually pass these props to your custom button.

formLoading​

Loading state of a modal. It's true when useForm is currently being submitted or data is being fetched for the "edit" or "clone" mode.

FAQ​

How can Invalidate other resources?​

You can invalidate other resources with help of useInvalidate hook.

It is useful when you want to invalidate other resources don't have relation with the current resource.

import React from "react";
import { useInvalidate } from "@refinedev/core";
import { useForm } from "@refinedev/react-hook-form";

const PostEdit = () => {
const invalidate = useInvalidate();

useForm({
refineCoreProps: {
onMutationSuccess: (data, variables, context) => {
invalidate({
resource: "users",
invalidates: ["resourceAll"],
});
},
},
});

// ---
};

How can I change the form data before submitting it to the API?​

You may need to modify the form data before it is sent to the API.

For example, Let's send the values we received from the user in two separate inputs, name and surname, to the API as fullName.

pages/user/create.tsx
import React from "react";
import { useForm } from "@refinedev/react-hook-form";
import { FieldValues } from "react-hook-form";

export const UserCreate: React.FC = () => {
const {
refineCore: { onFinish },
register,
handleSubmit,
} = useForm();

const onFinishHandler = (data: FieldValues) => {
onFinish({
fullName: `${data.name} ${data.surname}`,
});
};

return (
<form onSubmit={handleSubmit(onFinishHandler)}>
<label>Name: </label>
<input {...register("name")} />
<br />

<label>Surname: </label>
<input {...register("surname")} />
<br />

<button type="submit">Submit</button>
</form>
);
};

How to pass meta values only for the mutation or query?​

You can use meta property to pass common values to the mutation and the query. But in some cases, you may want to pass different values to the mutation and the query. To do this, you can use mutationMeta and queryMeta properties.

API​

Properties​

*: These properties have default values in RefineContext and can also be set on the <Refine> component.

External Props

It also accepts all props of useForm hook available in the React Hook Form.


For example, we can define the refineCoreProps property in the useForm hook as:

import { useForm } from "@refinedev/react-hook-form";

const { ... } = useForm({
...,
refineCoreProps: {
resource: "posts",
redirect: false,
// You can define all properties provided by refine useForm
},
});

Return values​

Returns all the properties returned by React Hook Form of the useForm hook. Also, we added the following return values:

refineCore: Returns all values returned by useForm. You can see all of them in here.

For example, we can access the refineCore return value in the useForm hook as:

import { useForm } from "@refinedev/react-hook-form";

const {
refineCore: { queryResult, ... },
} = useForm({ ... });
PropertyDescriptionType
saveButtonPropsProps for a submit button{ disabled: boolean; onClick: (e: React.BaseSyntheticEvent) => void; }

Type Parameters​

PropertyDesriptionTypeDefault
TQueryFnDataResult data returned by the query function. Extends BaseRecordBaseRecordBaseRecord
TErrorCustom error object that extends HttpErrorHttpErrorHttpError
TVariablesField Values for mutation function{}{}
TContextSecond generic type of the useForm of the React Hook Form.{}{}
TDataResult data returned by the select function. Extends BaseRecord. If not specified, the value of TQueryFnData will be used as the default value.BaseRecordTQueryFnData
TResponseResult data returned by the mutation function. Extends BaseRecord. If not specified, the value of TData will be used as the default value.BaseRecordTData
TResponseErrorCustom error object that extends HttpError. If not specified, the value of TError will be used as the default value.HttpErrorTError

Example​

RUN IN YOUR LOCAL
npm create refine-app@latest -- --example form-react-hook-form-use-form