useForm

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

import { useState } from "react";
import { useForm } from "@pankod/refine-core";

const PostCreate = () => {
  const [title, setTitle] = useState();
  const { onFinish } = useForm({
    action: "create",
  });

  const onSubmit = (e) => {
    e.preventDefault();
    onFinish({ title });
  };

  return (
    <form onSubmit={onSubmit}>
      <input onChange={(e) => setTitle(e.target.value)} />
      <button type="submit">Submit</button>
    </form>
  );
};

• Returns the mutationResult after called the onFinish callback.
• Accepts generic type parameters. It is used to define response type of the mutation and query.

useForm can handle edit, create and clone actions.

import React, { useState } from "react";
import { useForm } from "@pankod/refine-core";

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

const PostCreatePage: React.FC = () => {
  const { formLoading, onFinish } = useForm<IPost, HttpError, FormValues>();

  const [formValues, seFormValues] = useState<FormValues>({
    title: "",
    content: "",
  });

  const handleOnChange = (
    e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,
  ) => {
    seFormValues({
      ...formValues,
      [e.target.name]: e.target.value,
    });
  };

  const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    onFinish(formValues);
  };

  return (
    <div>
      <form onSubmit={handleSubmit}>
        <div>
          <label htmlFor="title">Title</label>
          <input
            type="text"
            id="title"
            name="title"
            placeholder="Title"
            value={formValues.title}
            onChange={handleOnChange}
          />
        </div>

        <div>
          <label htmlFor="content">Content</label>
          <textarea
            id="content"
            name="content"
            placeholder="Content"
            value={formValues.content}
            onChange={handleOnChange}
          />
        </div>
        <button type="submit" disabled={formLoading}>
          {formLoading && <div>Loading...</div>}
          <span>Save</span>
        </button>
      </form>
    </div>
  );
};

import React, { useState, useEffect } from "react";
import { useForm } from "@pankod/refine-core";

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

const PostEditPage: React.FC = () => {
  const { formLoading, onFinish, queryResult } = useForm<FormValues>();
  const defaultValues = queryResult?.data?.data;

  const [formValues, seFormValues] = useState<FormValues>({
    title: defaultValues?.title || "",
    content: defaultValues?.content || "",
  });

  const handleOnChange = (
    e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,
  ) => {
    seFormValues({
      ...formValues,
      [e.target.name]: e.target.value,
    });
  };

  const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    onFinish(formValues);
  };

  useEffect(() => {
    seFormValues({
      title: defaultValues?.title || "",
      content: defaultValues?.content || "",
    });
  }, [defaultValues]);

  return (
    <div>
      <br />
      <form onSubmit={handleSubmit}>
        <div>
          <label htmlFor="title">Title</label>
          <input
            type="text"
            id="title"
            name="title"
            placeholder="Title"
            value={formValues.title}
            onChange={handleOnChange}
          />
        </div>
        <div>
          <label htmlFor="content">Content</label>
          <textarea
            id="content"
            name="content"
            placeholder="Content"
            rows={10}
            value={formValues.content}
            onChange={handleOnChange}
          />
        </div>
        <button type="submit" disabled={formLoading}>
          {formLoading && <div>Loading...</div>}
          <span>Save</span>
        </button>
      </form>
    </div>
  );
};

import React, { useState, useEffect } from "react";
import { useForm } from "@pankod/refine-core";

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

const PostCreatePage: React.FC = () => {
  const { formLoading, onFinish, queryResult } = useForm<FormValues>();
  const defaultValues = queryResult?.data?.data;

  const [formValues, seFormValues] = useState<FormValues>({
    title: defaultValues?.title || "",
    content: defaultValues?.content || "",
  });

  const handleOnChange = (
    e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,
  ) => {
    seFormValues({
      ...formValues,
      [e.target.name]: e.target.value,
    });
  };

  const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    onFinish(formValues);
  };

  useEffect(() => {
    seFormValues({
      title: defaultValues?.title || "",
      content: defaultValues?.content || "",
    });
  }, [defaultValues]);

  return (
    <div>
      <br />
      <form onSubmit={handleSubmit}>
        <div>
          <label htmlFor="title">Title</label>
          <input
            type="text"
            id="title"
            name="title"
            placeholder="Title"
            value={formValues.title}
            onChange={handleOnChange}
          />
        </div>
        <div>
          <label htmlFor="content">Content</label>
          <textarea
            id="content"
            name="content"
            placeholder="Content"
            rows={10}
            value={formValues.content}
            onChange={handleOnChange}
          />
        </div>
        <button type="submit" disabled={formLoading}>
          {formLoading && <div>Loading...</div>}
          <span>Save</span>
        </button>
      </form>
    </div>
  );
};

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",
});

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 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,
});

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 });
  },
});

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 });
  },
});

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"],
});

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.

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

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",
});

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",
    };
  },
});

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({
  errorNotification: (data, values, resource) => {
    return {
      message: `Something went wrong when deleting ${data.id}`,
      description: "Error",
      type: "error",
    };
  },
});

{
    "message": "Error when updating <resource-name> (status code: ${err.statusCode})" or "Error when creating <resource-name> (status code: ${err.statusCode})",
    "description": "Error",
    "type": "error",
}

metaData is used following two purposes:

• To pass additional information to data provider methods.
• Generate GraphQL queries using plain JavaScript Objects (JSON). Please refer GraphQL for more information.

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

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

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

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

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

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,
  },
});

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,
  },
});

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,
  },
});

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",
});

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

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

Params to pass to liveProvider's subscribe method.

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;

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;

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

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

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.

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 { useInvalidate, useForm } from "@pankod/refine-core";

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

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

  // ---
};

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.

import React, { useState } from "react";
import { useForm } from "@pankod/refine-core";

export const UserCreate: React.FC = () => {
  const [name, setName] = useState();
  const [surname, setSurname] = useState();

  const { onFinish } = useForm();

  const onSubmit = (e) => {
    e.preventDefault();
    const fullName = `${name} ${surname}`;
    onFinish({
      fullName: fullName,
      name,
      surname,
    });
  };

  return (
    <form onSubmit={onSubmit}>
      <input onChange={(e) => setName(e.target.value)} />
      <input onChange={(e) => setSurname(e.target.value)} />
      <button type="submit">Submit</button>
    </form>
  );
};

*: 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.