useForm

http://localhost:3000

import {
    Create as AntdCreate,
    List as AntdList,
    useForm as useAntdForm,
    useTable as useAntdTable,
    EditButton as AntdEditButton,
    CloneButton as AntdCloneButton,
} from "@refinedev/antd";
import {
    Table as AntdTable,
    Edit as AntdEdit,
    Form as AntdForm,
    Input as AntdInput,
    Space as AntdSpace,
} from "antd";

interface IPost {
    id: number;
    title: string;
    content: string;
}

const PostList = () => {
    const { tableProps } = useAntdTable();

    return (
        <AntdList>
            <AntdTable {...tableProps} rowKey="id">
                <AntdTable.Column dataIndex="id" title="ID" />
                <AntdTable.Column dataIndex="title" title="Title" />
                <AntdTable.Column
                    title="Actions"
                    dataIndex="actions"
                    render={(_, record) => (
                        <AntdSpace>
                            <AntdEditButton
                                hideText
                                size="small"
                                recordItemId={record.id}
                            />
                            <AntdCloneButton
                                hideText
                                size="small"
                                recordItemId={record.id}
                            />
                        </AntdSpace>
                    )}
                />
            </AntdTable>
        </AntdList>
    );
};

const PostEdit = () => {
    const { formProps, saveButtonProps } = useAntdForm();

    return (
        <AntdEdit saveButtonProps={saveButtonProps}>
            <AntdForm {...formProps} layout="vertical">
                <AntdForm.Item
                    label="Title"
                    name="title"
                    rules={[
                        {
                            required: true,
                        },
                    ]}
                >
                    <AntdInput />
                </AntdForm.Item>
                <AntdForm.Item
                    label="Content"
                    name="content"
                    rules={[
                        {
                            required: true,
                        },
                    ]}
                >
                    <AntdInput.TextArea />
                </AntdForm.Item>
            </AntdForm>
        </AntdEdit>
    );
};

const PostCreate = () => {
    const { formProps, saveButtonProps } = useAntdForm();

    return (
        <AntdCreate saveButtonProps={saveButtonProps}>
            <AntdForm {...formProps} layout="vertical">
                <AntdForm.Item
                    label="Title"
                    name="title"
                    rules={[
                        {
                            required: true,
                        },
                    ]}
                >
                    <AntdInput />
                </AntdForm.Item>
                <AntdForm.Item
                    label="Content"
                    name="content"
                    rules={[
                        {
                            required: true,
                        },
                    ]}
                >
                    <AntdInput.TextArea />
                </AntdForm.Item>
            </AntdForm>
        </AntdCreate>
    );
};

useForm is used to manage forms. It returns the necessary properties and methods to control the Antd Form. Also, it has been developed by using useForm imported from @refinedev/core package.

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.

Basic Usage

For more detailed usage examples please refer to the Ant Design Form documentation.

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

pages/posts/edit.tsx

import { Edit, useForm } from "@refinedev/antd";
import { Form, Input, Select } from "antd";

export const PostEdit: React.FC = () => {
    const { formProps, saveButtonProps } = useForm<IPost>();

    return (
        <Edit saveButtonProps={saveButtonProps}>
            <Form {...formProps} layout="vertical">
                <Form.Item label="Title" name="title">
                    <Input />
                </Form.Item>
                <Form.Item label="Status" name="status">
                    <Select
                        options={[
                            {
                                label: "Published",
                                value: "published",
                            },
                            {
                                label: "Draft",
                                value: "draft",
                            },
                            {
                                label: "Rejected",
                                value: "rejected",
                            },
                        ]}
                    />
                </Form.Item>
            </Form>
        </Edit>
    );
};

interface IPost {
    id: number;
    title: string;
    status: "published" | "draft" | "rejected";
}

formProps includes all necessary values to manage Ant Design Form components.

In the example if you navigate to /posts/edit/1234 it will manage the data of the post with id of 1234 in an editing context. See Actions on how useForm determines this is an editing context.

Since this is an edit form it will fill the form with the data of the post with id of 1234 and then the form will be ready to edit further and submit the changes.

Submit functionality is provided by saveButtonProps which includes all of the necessary props for a button to submit a form including automatically updating loading states.

useForm accepts type parameters for the record in use and for the response type of the mutation. IPost in the example represents the record to edit. It is also used as the default type for mutation response.

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 or the useDrawerForm hook.

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).

create

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

import React from "react";

import { Create, useForm } from "@refinedev/antd";
import { Form, Input } from "antd";

interface IPost {
    id: number;
    title: string;
    content: string;
}

const PostCreatePage: React.FC = () => {
    const { formProps, saveButtonProps } = useForm<IPost>();

    return (
        <Create saveButtonProps={saveButtonProps}>
            <Form {...formProps} layout="vertical">
                <Form.Item
                    label="Title"
                    name="title"
                    rules={[
                        {
                            required: true,
                        },
                    ]}
                >
                    <Input />
                </Form.Item>
                <Form.Item
                    label="Content"
                    name="content"
                    rules={[
                        {
                            required: true,
                        },
                    ]}
                >
                    <Input.TextArea />
                </Form.Item>
            </Form>
        </Create>
    );
};

edit

action: "edit" is used for editing an existing record. It requires the id for determining the record to edit. By default, it uses the id from the route. It can be changed with the setId function or id property.

It fetches the record data according to the id with useOne and returns the queryResult for you to fill the form. After the form is submitted, it updates the record with useUpdate.

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

http://localhost:3000

import React from "react";

import { Edit, useForm } from "@refinedev/antd";
import { Form, Input } from "antd";

interface IPost {
    id: number;
    title: string;
    content: string;
}

const PostEditPage: React.FC = () => {
    const { formProps, saveButtonProps } = useForm<IPost>();

    return (
        <Edit saveButtonProps={saveButtonProps}>
            <Form {...formProps} layout="vertical">
                <Form.Item
                    label="Title"
                    name="title"
                    rules={[
                        {
                            required: true,
                        },
                    ]}
                >
                    <Input />
                </Form.Item>
                <Form.Item
                    label="Content"
                    name="content"
                    rules={[
                        {
                            required: true,
                        },
                    ]}
                >
                    <Input.TextArea />
                </Form.Item>
            </Form>
        </Edit>
    );
};

clone

action: "clone" is used for cloning an existing record. It requires the id for determining the record to clone. By default, it uses the id from the route. It can be changed with the setId function.

You can think action:clone like save as. It's similar to action:edit but it creates a new record instead of updating the existing one.

It fetches the record data according to the id with useOne and returns the queryResult for you to fill the form. After the form is submitted, it creates a new record with useCreate.

http://localhost:3000

import React from "react";

import { Create, useForm } from "@refinedev/antd";
import { Form, Input, Space, Switch } from "antd";

interface IPost {
    id: number;
    title: string;
    content: string;
}

const PostCreatePage: React.FC = () => {
    const { formProps, saveButtonProps } = useForm<IPost>();

    return (
        <Create saveButtonProps={saveButtonProps}>
            <Form {...formProps} layout="vertical">
                <Form.Item
                    label="Title"
                    name="title"
                    rules={[
                        {
                            required: true,
                        },
                    ]}
                >
                    <Input />
                </Form.Item>
                <Form.Item
                    label="Content"
                    name="content"
                    rules={[
                        {
                            required: true,
                        },
                    ]}
                >
                    <Input.TextArea />
                </Form.Item>
            </Form>
        </Create>
    );
};

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.

• When action is "create", it will be passed to the create method from the dataProvider.
• When action is "edit", it will be passed to the update and the getOne method from the dataProvider.
• When action is "clone", it will be passed to the create and the getOne method from the dataProvider.

useForm({
    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/antd";
import { useParsed } from "@refinedev/core";

const { id } = useParsed();

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

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

import { useForm } from "@refinedev/antd";

const { setId } = useForm({
    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 useful when you want to edit or clone a resource from a different page.

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

useForm({
    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({
    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({
    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({
    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({
    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({
    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({
    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({
    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, useForm will call open function from NotificationProvider to show a success notification. With this prop, you can customize the success notification.

useForm({
    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 used following three purposes:

• To pass additional information to data provider methods.
• Generate GraphQL queries using plain JavaScript Objects (JSON). Please refer GraphQL for more information.
• To provide additional parameters to the redirection path after the form is submitted. If your route has additional parameters, you can use meta to provide them.

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({
    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,
        };
    },
    //...
};

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({
    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({
    createMutationOptions: {
        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({
    updateMutationOptions: {
        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({
    warnWhenUnsavedChanges: true,
});

submitOnEnter

Default: false

When it's true, pressing the Enter key will submit the form. It can be used to prevent the user from accidentally leaving the page.

useForm({
    submitOnEnter: 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({
    liveMode: "auto",
});

onLiveEvent

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

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

liveParams

Params to pass to liveProvider's subscribe method.

Return Values

tip

All core useForm return values also available in useForm.

form

It's a <Form> instance. You can refer to Antd <Form> for more information.

formProps

It's required to manage <Form> state and actions.

onFinish

is called when the form is submitted. It will call the appropriate mutation based on the action property.

The only difference between onFinish and formProps.onFinish is that passing a value to formProps.onFinishis mandatory, whereas onFinish can automatically retrieve values from the form state.

onValuesChange

The warnWhenUnsavedChanges feature requires this function to work. If you want to override the form's onValuesChange, keep this in mind.

onKeyUp

It's a function that will be called when a key is pressed. By default, it will call form.submit() function when the pressed key is Enter.

initialValues

When action is set to "edit" or "clone", initialValues will be set to the data returned from useOne hook.

saveButtonProps

It contains all the props needed by the "submit" button within the form (disabled,loading etc.). When saveButtonProps.onClick is called, it triggers form.submit(). 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.

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 { 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 { 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 { 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 { 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.

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 { Create, useForm } from "@refinedev/antd";
import { Form, Input } from "antd";

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

    useForm({
        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 { Create, useForm } from "@refinedev/antd";
import { Form, Input } from "antd";

export const UserCreate: React.FC = () => {
    const { formProps, saveButtonProps, onFinish } = useForm();

    const handleOnFinish = (values) => {
        onFinish({
            fullName: `${values.name} ${values.surname}`,
        });
    };

    return (
        <Create saveButtonProps={saveButtonProps}>
            <Form {...formProps} onFinish={handleOnFinish} layout="vertical">
                <Form.Item label="Name" name="name">
                    <Input />
                </Form.Item>
                <Form.Item label="Surname" name="surname">
                    <Input />
                </Form.Item>
            </Form>
        </Create>
    );
};

API Reference

Properties

*: These props have default values in RefineContext and can also be set on <Refine> component. useForm will use what is passed to <Refine> as default but a local value will override it.

Type Parameters

Property	Desription	Type	Default
TData	Result data returned by the query function. Extends BaseRecord	BaseRecord	BaseRecord
TError	Custom error object that extends HttpError	HttpError	HttpError
TVariables	Values for params.	{}
TSelectData	Result data returned by the select function. Extends BaseRecord. If not specified, the value of TData will be used as the default value.	BaseRecord	TData

Return values

Property	Description	Type
onFinish	Triggers the mutation	(values?: TVariables) => Promise<CreateResponse<TData> | UpdateResponse<TData> | void>
form	Ant Design form instance	FormInstance
formProps	Ant Design form props	FormProps
saveButtonProps	Props for a submit button	{ disabled: boolean; onClick: () => void; loading?:boolean; }
redirect	Redirect function for custom redirections	(redirect: "list"|"edit"|"show"|"create"| false ,idFromFunction?: BaseKey|undefined) => data
queryResult	Result of the query of a record	QueryObserverResult<T>
mutationResult	Result of the mutation triggered by submitting the form	UseMutationResult<T>
formLoading	Loading state of form request	boolean
id	Record id for clone and create action	BaseKey
setId	id setter	Dispatch<SetStateAction< string | number | undefined>>

Example

VIEW SOURCE CODE →

RUN IN YOUR LOCAL

npm create refine-app@latest -- --example form-antd-use-form