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

package/src/components/forms/TenantForm.tsx

@@ -0,0 +1,116 @@
+import { ComponentType, ReactElement, useCallback, useEffect, useState } from 'react'
+import { Slot } from '@radix-ui/react-slot'
+import { FormContextValue } from '../../types/forms'
+import { FormContext } from '../../contexts'
+import { useReferentiallyStableCallback } from '@contember/react-utils'
+
+const SlotForm = Slot as ComponentType<React.FormHTMLAttributes<HTMLFormElement>>
+
+
+type ExecuteResult<T extends FormContextValue<any, any, any>, OkResult = undefined> =
+	| ({ ok: true } & (OkResult extends undefined ? {} : { result: OkResult }))
+	| { ok: false, error?: T['errors'][number]['code'], developerMessage?: string, state?: T['state'] }
+
+export interface TenantFormProps<T extends FormContextValue<any, any, any>, OkResult = undefined> {
+	children: ReactElement
+	loading?: boolean
+	initialValues: T['values']
+	errorMapping?: Partial<Record<T['errors'][number]['code'], keyof T['values']>>
+	validate?: (args: { values: T['values'], state: T['state'] }) => T['errors'] | undefined
+	execute: (args: { values: T['values'], state: T['state'] }) => Promise<ExecuteResult<T, OkResult>>
+	onSuccess?: (args: { result: OkResult }) => void
+	onChange?: (args: { values: T['values'], state: T['state'], submit: () => Promise<void> }) => void
+}
+
+export const TenantForm = <T extends FormContextValue<any, any, any>, OkResult = undefined>({
+	children,
+	initialValues,
+	loading,
+	errorMapping,
+	validate: validateIn,
+	execute: executeIn,
+	onSuccess: onSuccessIn,
+	onChange: onChangeIn,
+}: TenantFormProps<T, OkResult>) => {
+	const [values, setValues] = useState<T['values']>(initialValues)
+
+	const [errors, setErrors] = useState<T['errors']>([])
+	const [state, setState] = useState<T['state']>(loading ? 'loading' : 'initial')
+
+	useEffect(() => {
+		if (loading) {
+			setState('loading')
+		}
+	}, [loading])
+
+	useEffect(() => {
+		if (state === 'loading' && !loading) {
+			setValues(initialValues)
+			setState('initial')
+		}
+	}, [initialValues, loading, state])
+
+	const validate = useReferentiallyStableCallback(validateIn || (() => undefined))
+	const onSuccess = useReferentiallyStableCallback(onSuccessIn || (() => undefined))
+	const execute = useReferentiallyStableCallback(executeIn)
+
+	const submit = useReferentiallyStableCallback(async (event?: React.FormEvent) => {
+		event?.preventDefault()
+		const errors = validate?.({ values, state }) ?? []
+		setErrors(errors)
+
+		if (errors.length > 0) {
+			setState('error')
+			return
+		}
+
+		setState('submitting')
+
+		try {
+			const response = await execute({ values, state })
+
+			if (!response.ok) {
+				const error = response.error
+				setState(response.state ?? 'error')
+				setErrors([{
+					code: error || 'UNKNOWN_ERROR',
+					developerMessage: response.developerMessage,
+					field: errorMapping && error && error in errorMapping ? errorMapping[error] : undefined,
+				}])
+			} else {
+				setState('success')
+				setValues(initialValues)
+				onSuccess?.({ result: 'result' in response ? response.result : undefined as OkResult })
+			}
+		} catch (e) {
+			console.error(e)
+			setState('error')
+			setErrors([{
+				code: 'UNKNOWN_ERROR',
+				developerMessage: typeof e === 'string' ? e : (e && typeof e === 'object' && 'message' in e && typeof e.message === 'string') ? e.message : undefined,
+			}])
+		}
+	})
+
+
+	const onChange = useReferentiallyStableCallback(onChangeIn || (() => undefined))
+	useEffect(() => {
+		onChange?.({ values, state, submit })
+	}, [onChange, state, submit, values])
+
+	const setValue = useCallback((field: string, value: string) => setValues(values => ({ ...values, [field]: value })), [])
+
+	return (
+		<FormContext.Provider value={{
+			values,
+			setValues,
+			state,
+			errors,
+			setValue: setValue,
+		} as unknown as T}>
+			<SlotForm onSubmit={submit}>
+				{children}
+			</SlotForm>
+		</FormContext.Provider>
+	)
+}

package/src/components/forms/UpdateProjectMemberForm.tsx

@@ -0,0 +1,77 @@
+import { ReactElement, useEffect, useState } from 'react'
+import { TenantForm } from './TenantForm'
+import { FormContextValue, FormError, FormState } from '../../types'
+import { useForm } from '../../contexts'
+import { UpdateProjectMemberErrorCode, MembershipInput } from '@contember/graphql-client-tenant'
+import { useProjectMembershipsQuery, useTenantQueryLoader, useUpdateProjectMemberMutation } from '../../hooks'
+
+export type UpdateProjectMemberFormValues = {
+	memberships: readonly MembershipInput[]
+}
+
+export type UpdateProjectMemberFormErrorCode =
+	| UpdateProjectMemberErrorCode
+	| 'UNKNOWN_ERROR'
+	| 'FIELD_REQUIRED'
+
+export type UpdateProjectMemberFormState = FormState
+
+export type UpdateProjectMemberFormError = FormError<UpdateProjectMemberFormValues, UpdateProjectMemberFormErrorCode>
+
+export type UpdateProjectMemberFormContextValue = FormContextValue<UpdateProjectMemberFormValues, UpdateProjectMemberFormErrorCode>
+
+export interface UpdateProjectMemberFormProps {
+	children: ReactElement
+	identityId: string
+	projectSlug: string
+	onSuccess?: (args: { }) => void
+}
+
+export const useUpdateProjectMemberForm = useForm as () => UpdateProjectMemberFormContextValue
+
+export const UpdateProjectMemberForm = ({ children, onSuccess, identityId, projectSlug }: UpdateProjectMemberFormProps) => {
+	const updateProjectMember = useUpdateProjectMemberMutation()
+	const [state] = useTenantQueryLoader(useProjectMembershipsQuery(), { projectSlug, identityId })
+	const [memberships, setMemberships] = useState<readonly MembershipInput[]>()
+
+	useEffect(() => {
+		setMemberships(state.state === 'success' ? state.data : undefined)
+	}, [state])
+
+	return (
+		<TenantForm<UpdateProjectMemberFormContextValue>
+			onSuccess={onSuccess}
+			loading={memberships === undefined}
+			initialValues={memberships ? { memberships } : { memberships: [] }}
+			onChange={({ values, submit }) => {
+				setMemberships(values?.memberships)
+			}}
+			validate={({ values }) => {
+				const errors: UpdateProjectMemberFormError[] = []
+				if (values.memberships.length === 0) {
+					errors.push({ code: 'FIELD_REQUIRED', field: 'memberships' })
+				}
+				return errors
+			}}
+			execute={async ({ values }) => {
+				return await updateProjectMember({
+					identityId,
+					projectSlug,
+					memberships: values.memberships,
+				})
+			}}
+			errorMapping={errorToField}
+		>
+			{children}
+		</TenantForm>
+	)
+}
+
+const errorToField: Record<UpdateProjectMemberErrorCode, keyof UpdateProjectMemberFormValues | undefined> = {
+	INVALID_MEMBERSHIP: 'memberships',
+	PROJECT_NOT_FOUND: undefined,
+	ROLE_NOT_FOUND: 'memberships',
+	VARIABLE_EMPTY: 'memberships',
+	VARIABLE_NOT_FOUND: 'memberships',
+	NOT_MEMBER: undefined,
+}

package/src/components/forms/index.ts

@@ -0,0 +1,10 @@
+export * from './CreateApiKeyForm'
+export * from './CreateSessionTokenForm'
+export * from './ChangeMyPasswordForm'
+export * from './InviteForm'
+export * from './LoginForm'
+export * from './PasswordResetForm'
+export * from './PasswordResetRequestForm'
+export * from './OtpPrepareForm'
+export * from './OtpConfirmForm'
+export * from './UpdateProjectMemberForm'

package/src/components/idp/IDP.tsx

@@ -0,0 +1,65 @@
+import { ReactNode, useEffect, useMemo, useRef, useState } from 'react'
+import { IDPMethodsContextProvider, IDPStateContextProvider } from '../../contexts'
+import { IDPInitError, IDPResponseError, IDPStateValue } from '../../types/idp'
+import { useHandleIDPResponse } from '../../internal/hooks/useHandleIDPResponse'
+import { useIDPAutoInitProvider } from '../../internal/hooks/useIDPAutoInit'
+import { useInitIDPRedirect } from '../../internal/hooks/useInitIDPRedirect'
+
+export interface IDPProps {
+	children: ReactNode
+	onLogin?: () => void
+	onInitError?: (error: IDPInitError) => void
+	onResponseError?: (error: IDPResponseError) => void
+}
+
+export const IDP = ({ children, onResponseError, onInitError, onLogin }: IDPProps) => {
+	const hasOauthResponse = useMemo(() => {
+		const params = new URLSearchParams(window.location.search)
+		return params.has('state') && (params.has('code') || params.has('id_token'))
+	}, [])
+
+	const autoInit = useIDPAutoInitProvider()
+	const [state, setState] = useState<IDPStateValue>(() => {
+		if (hasOauthResponse) {
+			return { type: 'processing_response' }
+		}
+		if (autoInit) {
+			return { type: 'processing_init' }
+		}
+		return { type: 'nothing' }
+	})
+	useHandleIDPResponse({ hasOauthResponse, setState, onLogin })
+
+	const initRedirect = useInitIDPRedirect({ setState })
+
+	const isFirstRender = useRef(true)
+	useEffect(() => {
+		if (!autoInit) {
+			return
+		}
+		if (!isFirstRender.current) {
+			return
+		}
+		isFirstRender.current = false
+		initRedirect({ provider: autoInit })
+	}, [autoInit, initRedirect])
+
+	useEffect(() => {
+		if (state.type === 'init_failed' && onInitError) {
+			onInitError(state.error)
+		}
+		if (state.type === 'response_failed' && onResponseError) {
+			onResponseError(state.error)
+		}
+	}, [onInitError, onResponseError, state])
+
+
+	return (
+		<IDPStateContextProvider.Provider value={state}>
+			<IDPMethodsContextProvider.Provider value={{ initRedirect }}>
+				{children}
+			</IDPMethodsContextProvider.Provider>
+		</IDPStateContextProvider.Provider>
+	)
+
+}

package/src/components/idp/IDPInitTrigger.tsx

@@ -0,0 +1,17 @@
+import { Slot } from '@radix-ui/react-slot'
+import { ComponentType, ReactElement } from 'react'
+import { useIDPMethods } from '../../contexts'
+
+const SlotButton = Slot as ComponentType<React.ButtonHTMLAttributes<HTMLButtonElement>>
+
+export interface IDPInitTriggerProps {
+	children: ReactElement
+	identityProvider: string
+}
+
+export const IDPInitTrigger = ({ identityProvider, ...props }: IDPInitTriggerProps) => {
+	const initIdp = useIDPMethods().initRedirect
+	return (
+		<SlotButton onClick={() => initIdp({ provider: identityProvider })}  {...props} />
+	)
+}

package/src/components/idp/IDPState.tsx

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

package/src/components/idp/index.ts

@@ -0,0 +1,3 @@
+export * from './IDPState'
+export * from './IDP'
+export * from './IDPInitTrigger'

package/src/components/index.ts

@@ -0,0 +1,5 @@
+export * from './IdentityProvider'
+export * from './IdentityState'
+export * from './forms'
+export * from './idp'
+export * from './triggers'

package/src/components/triggers/DisableOtpTrigger.tsx

@@ -0,0 +1,25 @@
+import { ReactElement, useCallback } from 'react'
+import { useDisableOtpMutation } from '../../hooks'
+import { TenantActionTrigger } from './TenantActionTrigger'
+import { useIdentityMethods } from '../../contexts'
+
+export interface DisableOtpTriggerProps {
+	children: ReactElement
+	onSuccess?: () => void
+	onError?: (e: unknown) => void
+}
+
+export const DisableOtpTrigger = ({ onSuccess, ...props }: DisableOtpTriggerProps) => {
+	const disableOtp = useDisableOtpMutation()
+	const { refreshIdentity } = useIdentityMethods()
+
+	return (
+		<TenantActionTrigger
+			execute={useCallback(() => disableOtp({}), [disableOtp])}
+			onSuccess={() => {
+				refreshIdentity()
+				onSuccess?.()
+			}} {...props}
+		/>
+	)
+}

package/src/components/triggers/LogoutTrigger.tsx

@@ -0,0 +1,10 @@
+import { ReactNode, useCallback } from 'react'
+import { Slot } from '@radix-ui/react-slot'
+import { useLogout } from '../../hooks/useLogout'
+
+export const LogoutTrigger = ({ children }: {
+	children: ReactNode
+}) => {
+	const logout = useLogout()
+	return <Slot onClick={useCallback(() => logout(), [logout])}>{children}</Slot>
+}

package/src/components/triggers/RemoveProjectMemberTrigger.tsx

@@ -0,0 +1,18 @@
+import { ReactElement, useCallback } from 'react'
+import { TenantActionTrigger } from './TenantActionTrigger'
+import { RemoveProjectMemberMutationVariables, useRemoveProjectMemberMutation } from '../../hooks'
+
+export type RemoveProjectMemberTriggerProps =
+	& RemoveProjectMemberMutationVariables
+	& {
+		children: ReactElement
+		onSuccess?: () => void
+		onError?: (e: unknown) => void
+	}
+
+
+export const RemoveProjectMemberTrigger = ({ identityId, projectSlug, ...props }: RemoveProjectMemberTriggerProps) => {
+	const removeProjectMember = useRemoveProjectMemberMutation()
+	const execute = useCallback(async () => await removeProjectMember({ projectSlug, identityId }), [identityId, projectSlug, removeProjectMember])
+	return <TenantActionTrigger {...props} execute={execute} />
+}

package/src/components/triggers/TenantActionTrigger.tsx

@@ -0,0 +1,41 @@
+import { Slot } from '@radix-ui/react-slot'
+import { ComponentType, MouseEventHandler, ReactElement, useMemo, useState } from 'react'
+import { composeEventHandlers } from '@radix-ui/primitive'
+import { useReferentiallyStableCallback } from '@contember/react-utils'
+
+const SlotButton = Slot as ComponentType<React.ButtonHTMLAttributes<HTMLButtonElement>>
+
+export interface TenantActionTriggerProps<OkResult, Error extends string> {
+	children: ReactElement
+	onClick?: MouseEventHandler<HTMLButtonElement>
+	onSuccess?: (args: {result: OkResult}) => void
+	onError?: (args: { code: Error | 'UNKNOWN_ERROR', error: unknown }) => void
+	execute: () => Promise<({ ok: true } & (OkResult extends undefined ? {} : { result: OkResult })) | { ok: false, error?: Error }>
+}
+
+export const TenantActionTrigger = <OkResult, Error extends string>({ onError: onErrorIn, onSuccess: onSuccessIn, onClick: onClickProp, execute: executeIn, ...props }: TenantActionTriggerProps<OkResult, Error>) => {
+	const [submitting, setSubmitting] = useState(false)
+
+	const onSuccess = useReferentiallyStableCallback(onSuccessIn || (() => undefined))
+	const onError = useReferentiallyStableCallback(onErrorIn || (() => undefined))
+	const execute = useReferentiallyStableCallback(executeIn)
+
+	const onClick = useMemo(() => async () => {
+		setSubmitting(true)
+		try {
+			const response = await execute()
+			setSubmitting(false)
+			if (response.ok) {
+				onSuccess?.({ result: 'result' in response ? response.result : undefined as OkResult })
+			} else {
+				onError?.({ code: response.error ?? 'UNKNOWN_ERROR', error: response })
+			}
+		} catch (e) {
+			console.error(e)
+			setSubmitting(false)
+			onError?.({ code: 'UNKNOWN_ERROR', error: e })
+		}
+	}, [execute, onError, onSuccess])
+
+	return <SlotButton onClick={composeEventHandlers(onClickProp, onClick)} disabled={submitting} {...props} />
+}

package/src/components/triggers/index.ts

@@ -0,0 +1,3 @@
+export * from './DisableOtpTrigger'
+export * from './LogoutTrigger'
+export * from './RemoveProjectMemberTrigger'

package/src/contexts.ts

@@ -0,0 +1,34 @@
+import { createContext, createRequiredContext } from '@contember/react-utils'
+import { FormContextValue, Identity, IdentityMethods, IdentityStateValue, IDPMethods, IDPStateValue } from './types'
+
+const IdentityContext_ = createContext<Identity | undefined>('IdentityContext', undefined)
+/** @internal */
+export const IdentityContext = IdentityContext_[0]
+export const useIdentity = IdentityContext_[1]
+
+const IdentityMethodsContext_ = createRequiredContext<IdentityMethods>('IdentityMethodsContext')
+/** @internal */
+export const IdentityMethodsContext = IdentityMethodsContext_[0]
+export const useIdentityMethods = IdentityMethodsContext_[1]
+
+const IdentityStateContext_ = createRequiredContext<IdentityStateValue>('IdentityStateContext')
+/** @internal */
+export const IdentityStateContext = IdentityStateContext_[0]
+export const useIdentityState = IdentityStateContext_[1]
+
+
+const FormContext_ = createRequiredContext<FormContextValue<any, any, any>>('FormContext')
+/** @internal */
+export const FormContext = FormContext_[0]
+export const useForm = FormContext_[1]
+
+
+const IDPStateContext = createRequiredContext<IDPStateValue>('IDPStateContext')
+/** @internal */
+export const IDPStateContextProvider = IDPStateContext[0]
+export const useIDPState = IDPStateContext[1]
+
+const IDPMethodsContext = createRequiredContext<IDPMethods>('IDPMethodsContext')
+/** @internal */
+export const IDPMethodsContextProvider = IDPMethodsContext[0]
+export const useIDPMethods = IDPMethodsContext[1]

package/src/hooks/index.ts

@@ -1 +1,7 @@
+export * from './mutations'
+export * from './queries'
+export * from './useFetchIdentity'
+export * from './useLogout'
 export * from './useTenantApi'
+export * from './useTenantQueryLoader'
+export * from './useTenantMutation'

package/src/hooks/mutations/apiKey/index.ts

@@ -0,0 +1,4 @@
+export * from './useCreateApiKeyMutation'
+export * from './useCreateSessionTokenMutation'
+export * from './useCreateGlobalApiKeyMutation'
+export * from './useDisableApiKeyMutation'

package/src/hooks/mutations/apiKey/useCreateApiKeyMutation.tsx

@@ -0,0 +1,19 @@
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { ModelType } from 'graphql-ts-client-api'
+import { createTenantMutation } from '../../useTenantMutation'
+
+const createApiKeyMutationResult = TenantApi.createApiKeyResult$.apiKey(TenantApi.apiKeyWithToken$$.identity(TenantApi.identity$$))
+
+export type CreateApiKeyMutationResult = ModelType<typeof createApiKeyMutationResult>
+
+export const createApiKeyMutation = TenantApi.mutation$
+	.createApiKey(
+		TenantApi
+			.createApiKeyResponse$$
+			.error(TenantApi.createApiKeyError$$.membershipValidation(TenantApi.membershipValidationError$$))
+			.result(createApiKeyMutationResult),
+		options => options.alias('mutation'),
+	)
+
+export const useCreateApiKeyMutation = createTenantMutation(createApiKeyMutation)
+export type CreateApiKeyMutationVariables = Parameters<ReturnType<typeof useCreateApiKeyMutation>>[0]

package/src/hooks/mutations/apiKey/useCreateGlobalApiKeyMutation.tsx

@@ -0,0 +1,19 @@
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { ModelType } from 'graphql-ts-client-api'
+import { createTenantMutation } from '../../useTenantMutation'
+
+const createGlobalApiKeyMutationResult = TenantApi.createApiKeyResult$.apiKey(TenantApi.apiKeyWithToken$$.identity(TenantApi.identity$$))
+
+export type CreateGlobalApiKeyMutationResult = ModelType<typeof createGlobalApiKeyMutationResult>
+
+export const createGlobalApiKeyMutation = TenantApi.mutation$
+	.createGlobalApiKey(
+		TenantApi
+			.createApiKeyResponse$$
+			.error(TenantApi.createApiKeyError$$)
+			.result(createGlobalApiKeyMutationResult),
+		options => options.alias('mutation'),
+	)
+
+export const useCreateGlobalApiKeyMutation = createTenantMutation(createGlobalApiKeyMutation)
+export type CreateGlobalApiKeyMutationVariables = Parameters<ReturnType<typeof useCreateGlobalApiKeyMutation>>[0]

package/src/hooks/mutations/apiKey/useCreateSessionTokenMutation.tsx

@@ -0,0 +1,19 @@
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { ModelType } from 'graphql-ts-client-api'
+import { createTenantMutation } from '../../useTenantMutation'
+
+const createSessionTokenMutationResult = TenantApi.createSessionTokenResult$.token.person(TenantApi.person$$)
+
+export type CreateSessionTokenMutationResult = ModelType<typeof createSessionTokenMutationResult>
+
+export const createSessionTokenMutation = TenantApi.mutation$
+	.createSessionToken(
+		TenantApi
+			.createSessionTokenResponse$$
+			.error(TenantApi.createSessionTokenError$$)
+			.result(createSessionTokenMutationResult),
+		options => options.alias('mutation'),
+	)
+
+export const useCreateSessionTokenMutation = createTenantMutation(createSessionTokenMutation)
+export type CreateSessionTokenMutationVariables = Parameters<ReturnType<typeof useCreateSessionTokenMutation>>[0]

package/src/hooks/mutations/apiKey/useDisableApiKeyMutation.tsx

@@ -0,0 +1,14 @@
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { createTenantMutation } from '../../useTenantMutation'
+
+
+export const disableApiKeyMutation = TenantApi.mutation$
+	.disableApiKey(
+		TenantApi
+			.disableApiKeyResponse$$
+			.error(TenantApi.disableApiKeyError$$),
+		options => options.alias('mutation'),
+	)
+
+export const useDisableApiKeyMutation = createTenantMutation(disableApiKeyMutation)
+export type DisableApiKeyMutationVariables = Parameters<ReturnType<typeof useDisableApiKeyMutation>>[0]

package/src/hooks/mutations/auth/index.ts

@@ -0,0 +1,3 @@
+export * from './useChangeMyPasswordMutation'
+export * from './useSignInMutation'
+export * from './useSignOutMutation'

package/src/hooks/mutations/auth/useChangeMyPasswordMutation.ts

@@ -0,0 +1,14 @@
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { createTenantMutation } from '../../useTenantMutation'
+
+export const changeMyPasswordMutation = TenantApi
+	.mutation$
+	.changeMyPassword(
+		TenantApi
+			.changeMyPasswordResponse$$
+			.error(TenantApi.changeMyPasswordError$$),
+		options => options.alias('mutation'),
+	)
+
+export const useChangeMyPasswordMutation = createTenantMutation(changeMyPasswordMutation)
+export type ChangeMyPasswordMutationVariables = Parameters<ReturnType<typeof useChangeMyPasswordMutation>>[0]

package/src/hooks/mutations/auth/useSignInMutation.ts

@@ -0,0 +1,25 @@
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { LoginToken } from '../../useTenantApi'
+import { ModelType } from 'graphql-ts-client-api'
+import { createTenantMutation } from '../../useTenantMutation'
+
+const signInResultFragment = TenantApi.signInResult$$.person(TenantApi.person$$)
+
+export type SignInMutationResult = ModelType<typeof signInResultFragment>
+
+export const signInMutation = TenantApi
+	.mutation$
+	.signIn(
+		TenantApi
+			.signInResponse$$
+			.error(TenantApi.signInError$$)
+			.result(signInResultFragment),
+		options => options.alias('mutation'),
+	)
+
+
+export const useSignInMutation = createTenantMutation(signInMutation, {
+	apiToken: LoginToken,
+})
+
+export type SignInMutationVariables = Parameters<ReturnType<typeof useSignInMutation>>[0]

package/src/hooks/mutations/auth/useSignOutMutation.ts

@@ -0,0 +1,12 @@
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { createTenantMutation } from '../../useTenantMutation'
+
+export const signOutMutation = TenantApi.mutation$.signOut(
+	TenantApi
+		.signOutResponse$$
+		.error(TenantApi.signOutError$$),
+	options => options.alias('mutation'),
+)
+
+export const useSignOutMutation = createTenantMutation(signOutMutation)
+export type SignOutMutationVariables = Parameters<ReturnType<typeof useSignOutMutation>>[0]

package/src/hooks/mutations/idp/index.ts

@@ -0,0 +1,2 @@
+export * from './useInitSignInIDPMutation'
+export * from './useSignInIdpMutation'

package/src/hooks/mutations/idp/useInitSignInIDPMutation.ts

@@ -0,0 +1,29 @@
+import * as TenantApi from '@contember/graphql-client-tenant'
+import { LoginToken } from '../../useTenantApi'
+import { createTenantMutation } from '../../useTenantMutation'
+import { ModelType } from 'graphql-ts-client-api'
+
+
+export type InitSignInIDPMutationVariables = {
+	identityProvider: string
+	data: {
+		redirectUrl?: string
+	} & {
+		[key: string]: string
+	}
+}
+export type InitSignInIDPMutationResult = ModelType<typeof TenantApi.initSignInIDPResult$$>
+
+const InitSignInIDPMutation = TenantApi
+	.mutation$
+	.initSignInIDP(
+		TenantApi
+			.initSignInIDPResponse$$
+			.error(TenantApi.initSignInIDPError$$)
+			.result(TenantApi.initSignInIDPResult$$),
+		options => options.alias('mutation'),
+	)
+
+export const useInitSignInIDPMutation = createTenantMutation<InitSignInIDPMutationResult, TenantApi.InitSignInIDPErrorCode, InitSignInIDPMutationVariables>(InitSignInIDPMutation, {
+	apiToken: LoginToken,
+})