@massimo.mazzoleni/cognito-max 1.0.0

package/src/ui/hooks/useSignInForm.ts

@@ -0,0 +1,245 @@
+import { useCallback, useState, type FormEvent } from 'react'
+import { useAuth } from '../../react/hooks/useAuth'
+import type { CognitoAuthError } from '../../core/errors'
+import type { MfaType, SignInResult } from '../../core/types'
+
+export type SignInStep = 'credentials' | 'mfa' | 'new_password' | 'mfa_setup'
+
+export interface UseSignInFormOptions {
+  onSuccess?: (result: Extract<SignInResult, { status: 'SUCCESS' }>) => void
+  onError?: (error: CognitoAuthError) => void
+}
+
+export interface UseSignInFormReturn {
+  step: SignInStep
+  isLoading: boolean
+  error: CognitoAuthError | null
+  mfaType: MfaType | null
+
+  credentials: {
+    email: string
+    password: string
+    setEmail(v: string): void
+    setPassword(v: string): void
+    onSubmit(e: FormEvent): void
+  }
+
+  mfa: {
+    code: string
+    setCode(v: string): void
+    onSubmit(e: FormEvent): void
+  }
+
+  newPassword: {
+    password: string
+    confirmPassword: string
+    requiredAttributes: string[]
+    setPassword(v: string): void
+    setConfirmPassword(v: string): void
+    onSubmit(e: FormEvent): void
+  }
+
+  mfaSetup: {
+    qrCodeUri: string | null
+    secretCode: string | null
+    totpCode: string
+    setTotpCode(v: string): void
+    /** Chiama setupTotpChallenge e popola qrCodeUri / secretCode */
+    start(): Promise<void>
+    /** Chiama verifyTotpChallenge poi handleSignInResult */
+    onVerify(e: FormEvent): void
+  }
+
+  reset(): void
+}
+
+export function useSignInForm(options: UseSignInFormOptions = {}): UseSignInFormReturn {
+  const {
+    signIn,
+    respondToMfaChallenge,
+    respondToNewPasswordChallenge,
+    setupTotpChallenge,
+    verifyTotpChallenge,
+  } = useAuth()
+
+  const [step, setStep] = useState<SignInStep>('credentials')
+  const [isLoading, setLoading] = useState(false)
+  const [error, setError] = useState<CognitoAuthError | null>(null)
+
+  const [email, setEmail] = useState('')
+  const [password, setPassword] = useState('')
+
+  const [mfaType, setMfaType] = useState<MfaType | null>(null)
+  const [challengeSession, setChallengeSession] = useState<string | null>(null)
+  const [mfaCode, setMfaCode] = useState('')
+
+  const [newPwd, setNewPwd] = useState('')
+  const [confirmPwd, setConfirmPwd] = useState('')
+  const [requiredAttributes, setRequiredAttributes] = useState<string[]>([])
+
+  // MFA setup during login (MFA_SETUP_REQUIRED challenge)
+  const [mfaSetupQrCodeUri, setMfaSetupQrCodeUri] = useState<string | null>(null)
+  const [mfaSetupSecretCode, setMfaSetupSecretCode] = useState<string | null>(null)
+  const [mfaSetupTotpCode, setMfaSetupTotpCode] = useState('')
+
+  const handleSignInResult = useCallback(
+    (result: SignInResult) => {
+      if (result.status === 'SUCCESS') {
+        options.onSuccess?.(result)
+      } else if (result.status === 'MFA_REQUIRED') {
+        setMfaType(result.mfaType)
+        setChallengeSession(result.challengeSession)
+        setStep('mfa')
+      } else if (result.status === 'NEW_PASSWORD_REQUIRED') {
+        setChallengeSession(result.challengeSession)
+        setRequiredAttributes(result.requiredAttributes)
+        setStep('new_password')
+      } else if (result.status === 'MFA_SETUP_REQUIRED') {
+        setChallengeSession(result.challengeSession)
+        setStep('mfa_setup')
+      }
+    },
+    [options],
+  )
+
+  const handleCredentialsSubmit = useCallback(
+    async (e: FormEvent) => {
+      e.preventDefault()
+      setError(null)
+      setLoading(true)
+      try {
+        const result = await signIn(email, password)
+        handleSignInResult(result)
+      } catch (err) {
+        const authErr = err as CognitoAuthError
+        setError(authErr)
+        options.onError?.(authErr)
+      } finally {
+        setLoading(false)
+      }
+    },
+    [email, password, signIn, handleSignInResult, options],
+  )
+
+  const handleMfaSubmit = useCallback(
+    async (e: FormEvent) => {
+      e.preventDefault()
+      if (!challengeSession || !mfaType) return
+      setError(null)
+      setLoading(true)
+      try {
+        const result = await respondToMfaChallenge(challengeSession, mfaCode, mfaType)
+        handleSignInResult(result)
+      } catch (err) {
+        const authErr = err as CognitoAuthError
+        setError(authErr)
+        options.onError?.(authErr)
+      } finally {
+        setLoading(false)
+      }
+    },
+    [challengeSession, mfaType, mfaCode, respondToMfaChallenge, handleSignInResult, options],
+  )
+
+  const handleNewPasswordSubmit = useCallback(
+    async (e: FormEvent) => {
+      e.preventDefault()
+      if (!challengeSession) return
+      if (newPwd !== confirmPwd) {
+        setError({ message: 'Le password non coincidono', code: 'INVALID_PASSWORD' } as CognitoAuthError)
+        return
+      }
+      setError(null)
+      setLoading(true)
+      try {
+        const result = await respondToNewPasswordChallenge(challengeSession, newPwd)
+        handleSignInResult(result)
+      } catch (err) {
+        const authErr = err as CognitoAuthError
+        setError(authErr)
+        options.onError?.(authErr)
+      } finally {
+        setLoading(false)
+      }
+    },
+    [challengeSession, newPwd, confirmPwd, respondToNewPasswordChallenge, handleSignInResult, options],
+  )
+
+  const handleMfaSetupStart = useCallback(async () => {
+    if (!challengeSession) return
+    setError(null)
+    setLoading(true)
+    try {
+      const result = await setupTotpChallenge(challengeSession)
+      setMfaSetupQrCodeUri(result.qrCodeUri)
+      setMfaSetupSecretCode(result.secretCode)
+    } catch (err) {
+      const authErr = err as CognitoAuthError
+      setError(authErr)
+      options.onError?.(authErr)
+    } finally {
+      setLoading(false)
+    }
+  }, [challengeSession, setupTotpChallenge, options])
+
+  const handleMfaSetupVerify = useCallback(
+    async (e: FormEvent) => {
+      e.preventDefault()
+      if (!challengeSession) return
+      setError(null)
+      setLoading(true)
+      try {
+        const result = await verifyTotpChallenge(challengeSession, mfaSetupTotpCode)
+        handleSignInResult(result)
+      } catch (err) {
+        const authErr = err as CognitoAuthError
+        setError(authErr)
+        options.onError?.(authErr)
+      } finally {
+        setLoading(false)
+      }
+    },
+    [challengeSession, mfaSetupTotpCode, verifyTotpChallenge, handleSignInResult, options],
+  )
+
+  const reset = useCallback(() => {
+    setStep('credentials')
+    setEmail('')
+    setPassword('')
+    setMfaCode('')
+    setNewPwd('')
+    setConfirmPwd('')
+    setError(null)
+    setMfaType(null)
+    setChallengeSession(null)
+    setMfaSetupQrCodeUri(null)
+    setMfaSetupSecretCode(null)
+    setMfaSetupTotpCode('')
+  }, [])
+
+  return {
+    step,
+    isLoading,
+    error,
+    mfaType,
+    credentials: { email, password, setEmail, setPassword, onSubmit: handleCredentialsSubmit },
+    mfa: { code: mfaCode, setCode: setMfaCode, onSubmit: handleMfaSubmit },
+    newPassword: {
+      password: newPwd,
+      confirmPassword: confirmPwd,
+      requiredAttributes,
+      setPassword: setNewPwd,
+      setConfirmPassword: setConfirmPwd,
+      onSubmit: handleNewPasswordSubmit,
+    },
+    mfaSetup: {
+      qrCodeUri: mfaSetupQrCodeUri,
+      secretCode: mfaSetupSecretCode,
+      totpCode: mfaSetupTotpCode,
+      setTotpCode: setMfaSetupTotpCode,
+      start: handleMfaSetupStart,
+      onVerify: handleMfaSetupVerify,
+    },
+    reset,
+  }
+}

package/src/ui/index.ts

@@ -0,0 +1,31 @@
+// Hooks headless (usa la logica senza dipendere dall'UI)
+export { useSignInForm } from './hooks/useSignInForm'
+export type { UseSignInFormOptions, UseSignInFormReturn, SignInStep } from './hooks/useSignInForm'
+
+export { useRegisterForm } from './hooks/useRegisterForm'
+export type { UseRegisterFormOptions, UseRegisterFormReturn, RegisterStep } from './hooks/useRegisterForm'
+
+export { useForgotPasswordForm } from './hooks/useForgotPasswordForm'
+export type { UseForgotPasswordFormOptions, UseForgotPasswordFormReturn, ForgotPasswordStep } from './hooks/useForgotPasswordForm'
+
+export { useChangePasswordForm } from './hooks/useChangePasswordForm'
+export type { UseChangePasswordFormOptions, UseChangePasswordFormReturn } from './hooks/useChangePasswordForm'
+
+export { useMfaSetup } from './hooks/useMfaSetup'
+export type { UseMfaSetupOptions, UseMfaSetupReturn, MfaSetupStep } from './hooks/useMfaSetup'
+
+// Componenti default (HTML puro, nessuna dipendenza da design system)
+export { SignInForm } from './components/SignInForm'
+export type { SignInFormProps } from './components/SignInForm'
+
+export { RegisterForm } from './components/RegisterForm'
+export type { RegisterFormProps } from './components/RegisterForm'
+
+export { ForgotPasswordForm } from './components/ForgotPasswordForm'
+export type { ForgotPasswordFormProps } from './components/ForgotPasswordForm'
+
+export { ChangePasswordForm } from './components/ChangePasswordForm'
+export type { ChangePasswordFormProps } from './components/ChangePasswordForm'
+
+export { MfaSetupWizard } from './components/MfaSetupWizard'
+export type { MfaSetupWizardProps } from './components/MfaSetupWizard'