@contember/react-client-tenant 1.3.0-alpha.26 → 2.0.0-alpha.1

package/src/components/IdentityState.tsx

@@ -0,0 +1,14 @@
+import React, { ReactNode } from 'react'
+import { IdentityStateValue } from '../types'
+import { useIdentityState } from '../contexts'
+
+export interface IdentityStateProps {
+	state: IdentityStateValue | IdentityStateValue[]
+	children: ReactNode
+}
+
+export const IdentityState = ({ state, children }: IdentityStateProps) => {
+	const currentState = useIdentityState()
+
+	return state === currentState || (Array.isArray(state) && state.includes(currentState)) ? <>{children}</> : null
+}

package/src/components/forms/ChangeMyPasswordForm.tsx

@@ -0,0 +1,75 @@
+import { ReactElement } from 'react'
+import { ChangeMyPasswordErrorCode } from '@contember/graphql-client-tenant'
+import { TenantForm } from './TenantForm'
+import { FormContextValue, FormError, FormState } from '../../types'
+import { useForm } from '../../contexts'
+import { useChangeMyPasswordMutation } from '../../hooks'
+
+export type ChangeMyPasswordFormValues = {
+	currentPassword: string
+	newPassword: string
+	passwordConfirmation: string
+}
+
+export type ChangeMyPasswordFormErrorCode =
+	| ChangeMyPasswordErrorCode
+	| 'FIELD_REQUIRED'
+	| 'INVALID_VALUE'
+	| 'PASSWORD_MISMATCH'
+	| 'UNKNOWN_ERROR'
+
+export type ChangeMyPasswordFormState = FormState
+
+export type ChangeMyPasswordFormError = FormError<ChangeMyPasswordFormValues, ChangeMyPasswordFormErrorCode>
+
+export type ChangeMyPasswordFormContextValue = FormContextValue<ChangeMyPasswordFormValues, ChangeMyPasswordFormErrorCode>
+
+export interface ChangeMyPasswordFormProps {
+	children: ReactElement
+	onSuccess?: () => void
+}
+
+export const useChangeMyPasswordForm = useForm as () => ChangeMyPasswordFormContextValue
+
+export const ChangeMyPasswordForm = ({ children, onSuccess }: ChangeMyPasswordFormProps) => {
+	const changePassword = useChangeMyPasswordMutation()
+	return (
+		<TenantForm<ChangeMyPasswordFormContextValue>
+			onSuccess={onSuccess}
+			errorMapping={errorToField}
+			initialValues={{
+				currentPassword: '',
+				newPassword: '',
+				passwordConfirmation: '',
+			}}
+			validate={({ values }) => {
+				const errors: ChangeMyPasswordFormError[] = []
+				if (!values.currentPassword) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'currentPassword' })
+				}
+				if (!values.newPassword) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'newPassword' })
+				} else if (values.newPassword.length < 6) {
+					errors.push({ code: 'INVALID_VALUE', field: 'newPassword' })
+				} else if (!values.passwordConfirmation) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'passwordConfirmation' })
+				} else if (values.newPassword !== values.passwordConfirmation) {
+					errors.push({ code: 'PASSWORD_MISMATCH', field: 'passwordConfirmation' })
+				}
+				return errors
+			}}
+			execute={async ({ values }) => {
+				return await changePassword(values)
+			}}
+		>
+			{children}
+		</TenantForm>
+	)
+
+}
+const errorToField: Partial<Record<ChangeMyPasswordFormErrorCode, keyof ChangeMyPasswordFormValues | undefined>> = {
+	PASSWORD_MISMATCH: 'passwordConfirmation',
+	TOO_WEAK: 'newPassword',
+	NO_PASSWORD_SET: 'currentPassword',
+	INVALID_PASSWORD: 'currentPassword',
+}

package/src/components/forms/CreateApiKeyForm.tsx

@@ -0,0 +1,72 @@
+import { ReactElement } from 'react'
+import { TenantForm } from './TenantForm'
+import { FormContextValue, FormError, FormState } from '../../types'
+import { useForm } from '../../contexts'
+import { CreateApiKeyErrorCode, MembershipInput } from '@contember/graphql-client-tenant'
+import { CreateApiKeyMutationResult, useCreateApiKeyMutation } from '../../hooks'
+
+export type CreateApiKeyFormValues = {
+	description: string
+	memberships: readonly MembershipInput[]
+}
+
+export type CreateApiKeyFormErrorCode =
+	| CreateApiKeyErrorCode
+	| 'UNKNOWN_ERROR'
+	| 'FIELD_REQUIRED'
+
+export type CreateApiKeyFormState = FormState
+
+export type CreateApiKeyFormError = FormError<CreateApiKeyFormValues, CreateApiKeyFormErrorCode>
+
+export type CreateApiKeyFormContextValue = FormContextValue<CreateApiKeyFormValues, CreateApiKeyFormErrorCode>
+
+export interface CreateApiKeyFormProps {
+	children: ReactElement
+	projectSlug: string
+	initialMemberships?: readonly MembershipInput[]
+	onSuccess?: (args: { result: CreateApiKeyMutationResult }) => void
+}
+
+export const useCreateApiKeyForm = useForm as () => CreateApiKeyFormContextValue
+
+export const CreateApiKeyForm = ({ children, onSuccess, projectSlug, initialMemberships }: CreateApiKeyFormProps) => {
+	const createApiKey = useCreateApiKeyMutation()
+	return (
+		<TenantForm<CreateApiKeyFormContextValue, CreateApiKeyMutationResult>
+			onSuccess={onSuccess}
+			initialValues={{
+				description: '',
+				memberships: initialMemberships || [],
+			}}
+			validate={({ values }) => {
+				const errors: CreateApiKeyFormError[] = []
+				if (!values.description) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'description' })
+				}
+				if (values.memberships.length === 0) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'memberships' })
+				}
+				return errors
+			}}
+			execute={async ({ values }) => {
+				return await createApiKey({
+					description: values.description,
+					projectSlug,
+					memberships: values.memberships,
+				})
+			}}
+			errorMapping={errorToField}
+		>
+			{children}
+		</TenantForm>
+	)
+}
+
+const errorToField: Record<CreateApiKeyErrorCode, keyof CreateApiKeyFormValues | undefined> = {
+	INVALID_MEMBERSHIP: 'memberships',
+	PROJECT_NOT_FOUND: undefined,
+	ROLE_NOT_FOUND: 'memberships',
+	VARIABLE_EMPTY: 'memberships',
+	VARIABLE_NOT_FOUND: 'memberships',
+}

package/src/components/forms/CreateSessionTokenForm.tsx

@@ -0,0 +1,64 @@
+import { ReactElement } from 'react'
+import { TenantForm } from './TenantForm'
+import { FormContextValue, FormError, FormState } from '../../types'
+import { useForm } from '../../contexts'
+import { CreateSessionTokenErrorCode } from '@contember/graphql-client-tenant'
+import { CreateSessionTokenMutationResult, useCreateSessionTokenMutation } from '../../hooks'
+
+export type CreateSessionTokenFormValues = {
+	email: string
+}
+
+export type CreateSessionTokenFormErrorCode =
+	| CreateSessionTokenErrorCode
+	| 'UNKNOWN_ERROR'
+	| 'FIELD_REQUIRED'
+
+export type CreateSessionTokenFormState = FormState
+
+export type CreateSessionTokenFormError = FormError<CreateSessionTokenFormValues, CreateSessionTokenFormErrorCode>
+
+export type CreateSessionTokenFormContextValue = FormContextValue<CreateSessionTokenFormValues, CreateSessionTokenFormErrorCode>
+
+export interface CreateSessionTokenFormProps {
+	children: ReactElement
+	expiration?: number
+	apiToken?: string
+	onSuccess?: (args: { result: CreateSessionTokenMutationResult }) => void
+}
+
+export const useCreateSessionTokenForm = useForm as () => CreateSessionTokenFormContextValue
+
+export const CreateSessionTokenForm = ({ children, onSuccess, expiration, apiToken }: CreateSessionTokenFormProps) => {
+	const createSessionToken = useCreateSessionTokenMutation({ apiToken })
+	return (
+		<TenantForm<CreateSessionTokenFormContextValue, CreateSessionTokenMutationResult>
+			onSuccess={onSuccess}
+			initialValues={{
+				email: '',
+			}}
+			validate={({ values }) => {
+				const errors: CreateSessionTokenFormError[] = []
+				if (!values.email) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'email' })
+				}
+				return errors
+			}}
+			execute={async ({ values }) => {
+				return await createSessionToken({
+					email: values.email,
+					expiration,
+				})
+			}}
+			errorMapping={errorToField}
+		>
+			{children}
+		</TenantForm>
+	)
+}
+
+const errorToField: Record<CreateSessionTokenErrorCode, keyof CreateSessionTokenFormValues | undefined> = {
+	PERSON_DISABLED: 'email',
+	UNKNOWN_EMAIL: 'email',
+	UNKNOWN_PERSON_ID: 'email',
+}

package/src/components/forms/InviteForm.tsx

@@ -0,0 +1,79 @@
+import { ReactElement } from 'react'
+import { TenantForm } from './TenantForm'
+import { FormContextValue, FormError, FormState } from '../../types'
+import { useForm } from '../../contexts'
+import { InviteErrorCode, InviteOptions, MembershipInput } from '@contember/graphql-client-tenant'
+import { InviteMutationResult, useInviteMutation } from '../../hooks'
+
+export type InviteFormValues = {
+	email: string
+	name: string
+	memberships: readonly MembershipInput[]
+}
+
+export type InviteFormErrorCode =
+	| InviteErrorCode
+	| 'UNKNOWN_ERROR'
+	| 'FIELD_REQUIRED'
+
+export type InviteFormState = FormState
+
+export type InviteFormError = FormError<InviteFormValues, InviteFormErrorCode>
+
+export type InviteFormContextValue = FormContextValue<InviteFormValues, InviteFormErrorCode>
+
+export interface InviteFormProps {
+	children: ReactElement
+	projectSlug: string
+	inviteOptions?: InviteOptions
+	initialMemberships?: readonly MembershipInput[]
+	onSuccess?: (args: { result: InviteMutationResult }) => void
+}
+
+export const useInviteForm = useForm as () => InviteFormContextValue
+
+export const InviteForm = ({ children, onSuccess, projectSlug, initialMemberships, inviteOptions }: InviteFormProps) => {
+	const invite = useInviteMutation()
+	return (
+		<TenantForm<InviteFormContextValue, InviteMutationResult>
+			onSuccess={onSuccess}
+			initialValues={{
+				email: '',
+				name: '',
+				memberships: initialMemberships || [],
+			}}
+			validate={({ values }) => {
+				const errors: InviteFormError[] = []
+				if (!values.email) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'email' })
+				}
+				if (values.memberships.length === 0) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'memberships' })
+				}
+				return errors
+			}}
+			execute={async ({ values }) => {
+				return await invite({
+					email: values.email,
+					name: values.name,
+					projectSlug,
+					options: inviteOptions,
+					memberships: values.memberships,
+				})
+			}}
+			errorMapping={errorToField}
+		>
+			{children}
+		</TenantForm>
+	)
+}
+
+const errorToField: Record<InviteErrorCode, keyof InviteFormValues | undefined> = {
+	ALREADY_MEMBER: 'email',
+	INVALID_EMAIL_FORMAT: 'email',
+	INVALID_MEMBERSHIP: 'memberships',
+	PROJECT_NOT_FOUND: undefined,
+	ROLE_NOT_FOUND: 'memberships',
+	VARIABLE_EMPTY: 'memberships',
+	VARIABLE_NOT_FOUND: 'memberships',
+}

package/src/components/forms/LoginForm.tsx

@@ -0,0 +1,110 @@
+import { ReactElement, useCallback, useMemo } from 'react'
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { TenantForm } from './TenantForm'
+import { SignInErrorCode } from '@contember/graphql-client-tenant'
+import { FormContextValue, FormError, FormState } from '../../types'
+import { useForm } from '../../contexts'
+import { useSetSessionToken } from '@contember/react-client'
+import { SignInMutationResult, useSignInMutation } from '../../hooks'
+import { useRedirectToBacklinkCallback } from '../../internal/hooks/useRedirectToBacklink'
+
+
+export type LoginFormValues = {
+	email: string
+	password: string
+	otpToken: string
+}
+
+export type LoginFormErrorCode =
+	| SignInErrorCode
+	| 'FIELD_REQUIRED'
+	| 'INVALID_VALUE'
+	| 'UNKNOWN_ERROR'
+
+export type LoginFormState =
+	| FormState
+	| 'otp-required'
+
+export type LoginFormError = FormError<LoginFormValues, LoginFormErrorCode>
+
+export type LoginFormContextValue = FormContextValue<LoginFormValues, LoginFormErrorCode, LoginFormState>
+
+export interface LoginFormProps {
+	expiration?: number
+	children: ReactElement
+	onSuccess?: () => void
+}
+
+export const useLoginForm = useForm as () => LoginFormContextValue
+
+const headers = {
+	'X-Contember-Token-Path': 'data.mutation.result.token',
+}
+
+const DEFAULT_LOGIN_EXPIRATION = 14 * 24 * 3600 // 14 days
+
+export const LoginForm = ({ children, expiration = DEFAULT_LOGIN_EXPIRATION, onSuccess }: LoginFormProps) => {
+	const login = useSignInMutation({ headers })
+	const redirectToBacklink = useRedirectToBacklinkCallback()
+	const setSessionToken = useSetSessionToken()
+	return (
+		<TenantForm<LoginFormContextValue, SignInMutationResult>
+			onSuccess={args => {
+				onSuccess?.()
+				setSessionToken(args.result.token)
+				redirectToBacklink()
+			}}
+			errorMapping={errorToField}
+			initialValues={{
+				email: '',
+				password: '',
+				otpToken: '',
+			}}
+			validate={({ values, state }) => {
+				const errors: LoginFormError[] = []
+				if (!values.email) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'email' })
+				} else if (!values.email.match(/^.+@.+$/)) {
+					errors.push({ code: 'INVALID_VALUE', field: 'email' })
+				}
+
+				if (!values.password) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'password' })
+				} else if (values.password.length < 6) {
+					errors.push({ code: 'INVALID_VALUE', field: 'password' })
+				}
+				if (!values.otpToken && state === 'otp-required') {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'otpToken' })
+				} else if (values.otpToken && !values.otpToken.match(/^\d{6}$/)) {
+					errors.push({ code: 'INVALID_VALUE', field: 'otpToken' })
+				}
+				return errors
+			}}
+			execute={async ({ values }) => {
+				const result = await login({
+					email: values.email!,
+					password: values.password!,
+					otpToken: values.otpToken || undefined,
+					expiration: expiration,
+				})
+
+				if (!result.ok && result.error === 'OTP_REQUIRED') {
+					return { ...result, state: 'otp-required' }
+				}
+
+				return result
+			}}
+		>
+			{children}
+		</TenantForm>
+	)
+
+}
+const errorToField: Record<TenantApi.SignInErrorCode, keyof LoginFormValues | undefined> = {
+	'INVALID_PASSWORD': 'password',
+	'NO_PASSWORD_SET': 'password',
+	'UNKNOWN_EMAIL': 'email',
+	'PERSON_DISABLED': 'email',
+	'INVALID_OTP_TOKEN': 'otpToken',
+	'OTP_REQUIRED': undefined,
+}

package/src/components/forms/OtpConfirmForm.tsx

@@ -0,0 +1,61 @@
+import { ReactElement } from 'react'
+import { TenantForm } from './TenantForm'
+import { FormContextValue, FormError, FormState } from '../../types'
+import { useForm, useIdentityMethods } from '../../contexts'
+import { ConfirmOtpErrorCode } from '@contember/graphql-client-tenant'
+import { useConfirmOtpMutation } from '../../hooks'
+
+export type OtpConfirmFormValues = {
+	otpToken: string
+}
+
+export type OtpConfirmFormErrorCode =
+	| ConfirmOtpErrorCode
+	| 'FIELD_REQUIRED'
+	| 'UNKNOWN_ERROR'
+
+export type OtpConfirmFormState = FormState
+
+export type OtpConfirmFormError = FormError<OtpConfirmFormValues, OtpConfirmFormErrorCode>
+
+export type OtpConfirmFormContextValue = FormContextValue<OtpConfirmFormValues, OtpConfirmFormErrorCode>
+
+export interface OtpConfirmFormProps {
+	children: ReactElement
+	onSuccess?: () => void
+}
+
+export const useOtpConfirmForm = useForm as () => OtpConfirmFormContextValue
+
+export const OtpConfirmForm = ({ children, onSuccess }: OtpConfirmFormProps) => {
+	const confirmOtp = useConfirmOtpMutation()
+	const { refreshIdentity } = useIdentityMethods()
+	return (
+		<TenantForm<OtpConfirmFormContextValue>
+			onSuccess={async args => {
+				await refreshIdentity()
+				onSuccess?.()
+			}}
+			initialValues={{
+				otpToken: '',
+			}}
+			validate={({ values }) => {
+				if (!values.otpToken) {
+					return [{ code: 'FIELD_REQUIRED', field: 'otpToken' }]
+				}
+			}}
+			execute={async ({ values }) => {
+				return await confirmOtp({
+					 otpToken: values.otpToken,
+				})
+			}}
+			errorMapping={{
+				INVALID_OTP_TOKEN: 'otpToken',
+				NOT_PREPARED: 'otpToken',
+			}}
+		>
+			{children}
+		</TenantForm>
+	)
+}
+

package/src/components/forms/OtpPrepareForm.tsx

@@ -0,0 +1,45 @@
+import { ReactElement, useCallback, useMemo } from 'react'
+import { TenantForm } from './TenantForm'
+import { FormContextValue, FormError, FormState } from '../../types'
+import { useForm } from '../../contexts'
+import { PrepareOtpMutationResult, usePrepareOtpMutation } from '../../hooks'
+
+export type OtpPrepareFormValues = {
+	label: string
+}
+
+export type OtpPrepareFormErrorCode =
+	| 'UNKNOWN_ERROR'
+
+export type OtpPrepareFormState = FormState
+
+export type OtpPrepareFormError = FormError<OtpPrepareFormValues, OtpPrepareFormErrorCode>
+
+export type OtpPrepareFormContextValue = FormContextValue<OtpPrepareFormValues, OtpPrepareFormErrorCode>
+
+export interface OtpPrepareFormProps {
+	children: ReactElement
+	onSuccess?: (args: { result: PrepareOtpMutationResult }) => void
+}
+
+export const useOtpPrepareForm = useForm as () => OtpPrepareFormContextValue
+
+export const OtpPrepareForm = ({ children, onSuccess }: OtpPrepareFormProps) => {
+	const prepareOtp = usePrepareOtpMutation()
+	return (
+		<TenantForm<OtpPrepareFormContextValue, PrepareOtpMutationResult>
+			onSuccess={onSuccess}
+			initialValues={{
+				label: window.location.hostname,
+			}}
+			execute={async ({ values }) => {
+				return await prepareOtp({
+					label: values.label,
+				})
+			}}
+		>
+			{children}
+		</TenantForm>
+	)
+}
+

package/src/components/forms/PasswordResetForm.tsx

@@ -0,0 +1,80 @@
+import { ReactElement } from 'react'
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { ResetPasswordErrorCode } from '@contember/graphql-client-tenant'
+import { TenantForm } from './TenantForm'
+import { FormContextValue, FormError, FormState } from '../../types'
+import { useForm } from '../../contexts'
+import { useResetPasswordMutation } from '../../hooks'
+
+export type PasswordResetFormValues = {
+	token: string
+	password: string
+	passwordConfirmation: string
+}
+
+export type PasswordResetFormErrorCode =
+	| ResetPasswordErrorCode
+	| 'FIELD_REQUIRED'
+	| 'INVALID_VALUE'
+	| 'PASSWORD_MISMATCH'
+	| 'UNKNOWN_ERROR'
+
+export type PasswordResetFormState = FormState
+
+export type PasswordResetFormError = FormError<PasswordResetFormValues, PasswordResetFormErrorCode>
+
+export type PasswordResetFormContextValue = FormContextValue<PasswordResetFormValues, PasswordResetFormErrorCode>
+
+export interface PasswordResetFormProps {
+	children: ReactElement
+	onSuccess?: () => void
+	token?: string
+}
+
+export const usePasswordResetForm = useForm as () => PasswordResetFormContextValue
+
+export const PasswordResetForm = ({ children, onSuccess, token }: PasswordResetFormProps) => {
+	const createReset = useResetPasswordMutation()
+	return (
+		<TenantForm<PasswordResetFormContextValue>
+			onSuccess={onSuccess}
+			errorMapping={errorToField}
+			initialValues={{
+				token: token ?? '',
+				password: '',
+				passwordConfirmation: '',
+			}}
+			validate={({ values }) => {
+				const errors: PasswordResetFormError[] = []
+				if (!values.token) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'token' })
+				}
+				if (!values.password) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'password' })
+				} else if (values.password.length < 6) {
+					errors.push({ code: 'INVALID_VALUE', field: 'password' })
+				} else if (!values.passwordConfirmation) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'passwordConfirmation' })
+				} else if (values.password !== values.passwordConfirmation) {
+					errors.push({ code: 'PASSWORD_MISMATCH', field: 'passwordConfirmation' })
+				}
+				return errors
+			}}
+			execute={async ({ values }) => {
+				return await createReset({
+					password: values.password,
+					token: values.token,
+				})
+			}}
+		>
+			{children}
+		</TenantForm>
+	)
+
+}
+const errorToField: Record<TenantApi.ResetPasswordErrorCode, keyof PasswordResetFormValues | undefined> = {
+	PASSWORD_TOO_WEAK: 'password',
+	TOKEN_EXPIRED: 'token',
+	TOKEN_NOT_FOUND: 'token',
+	TOKEN_USED: 'token',
+}

package/src/components/forms/PasswordResetRequestForm.tsx

@@ -0,0 +1,64 @@
+import { ReactElement, useCallback, useMemo } from 'react'
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { CreatePasswordResetRequestErrorCode } from '@contember/graphql-client-tenant'
+import { TenantForm } from './TenantForm'
+import { FormContextValue, FormError, FormState } from '../../types/forms'
+import { useForm } from '../../contexts'
+import { useCreateResetPasswordRequestMutation } from '../../hooks'
+
+export type PasswordResetRequestFormValues = {
+	email: string
+}
+
+export type PasswordResetRequestFormErrorCode =
+	| CreatePasswordResetRequestErrorCode
+	| 'FIELD_REQUIRED'
+	| 'INVALID_VALUE'
+	| 'UNKNOWN_ERROR'
+
+export type PasswordResetRequestFormState = FormState
+
+export type PasswordResetRequestFormError = FormError<PasswordResetRequestFormValues, PasswordResetRequestFormErrorCode>
+
+export type PasswordResetRequestFormContextValue = FormContextValue<PasswordResetRequestFormValues, PasswordResetRequestFormErrorCode>
+
+
+export interface PasswordResetRequestFormProps {
+	children: ReactElement
+	onSuccess?: () => void
+}
+
+export const usePasswordResetRequestForm = useForm as () => PasswordResetRequestFormContextValue
+
+export const PasswordResetRequestForm = ({ children, onSuccess }: PasswordResetRequestFormProps) => {
+
+	const createResetRequest = useCreateResetPasswordRequestMutation()
+	return (
+		<TenantForm<PasswordResetRequestFormContextValue>
+			onSuccess={onSuccess}
+			errorMapping={errorToField}
+			initialValues={useMemo(() => ({
+				email: '',
+			}), [])}
+			validate={({ values }) => {
+				if (!values.email) {
+					return [{ code: 'FIELD_REQUIRED', field: 'email' }]
+				} else if (!values.email.match(/^.+@.+$/)) {
+					return [{ code: 'INVALID_VALUE', field: 'email' }]
+				}
+				return []
+			}}
+			execute={useCallback(async ({ values }) => {
+				return await createResetRequest({
+					email: values.email,
+				})
+			}, [createResetRequest])}
+		>
+			{children}
+		</TenantForm>
+	)
+
+}
+const errorToField: Record<TenantApi.CreatePasswordResetRequestErrorCode, keyof PasswordResetRequestFormValues | undefined> = {
+	PERSON_NOT_FOUND: 'email',
+}