T3-Template/src/lib/actions/auth.ts

'use server';

import 'server-only';
import { encodedRedirect } from '@/utils/utils';
import { createServerClient } from '@/utils/supabase';
import { headers } from 'next/headers';
import { redirect } from 'next/navigation';
import type { User } from '@/utils/supabase';
import type { Result } from './index';

export const signUp = async (formData: FormData) => {
  const name = formData.get('name') as string;
  const email = formData.get('email') as string;
  const password = formData.get('password') as string;
  const supabase = await createServerClient();
  const origin = (await headers()).get('origin');

  if (!email || !password) {
    return encodedRedirect(
      'error',
      '/sign-up',
      'Email & password are required',
    );
  }

  const { error } = await supabase.auth.signUp({
    email,
    password,
    options: {
      emailRedirectTo: `${origin}/auth/callback`,
      data: {
        full_name: name,
        email,
        provider: 'email',
      },
    },
  });
  if (error) {
    return encodedRedirect('error', '/sign-up', error.message);
  } else {
    return encodedRedirect(
      'success',
      '/sign-up',
      'Thanks for signing up! Please check your email for a verification link.',
    );
  }
};

export const signIn = async (
  formData: FormData,
): Promise<Result<null>> => {
  const email = formData.get('email') as string;
  const password = formData.get('password') as string;
  const supabase = await createServerClient();

  const { error } = await supabase.auth.signInWithPassword({
    email,
    password,
  });
  if (error) {
    return { success: false, error: error.message };
  } else {
    return { success: true, data: null };
  }
};

export const forgotPassword = async (formData: FormData) => {
  const email = formData.get('email') as string;
  const supabase = await createServerClient();
  const origin = (await headers()).get('origin');
  const callbackUrl = formData.get('callbackUrl') as string;

  if (!email) {
    return encodedRedirect('error', '/forgot-password', 'Email is required');
  }

  const { error } = await supabase.auth.resetPasswordForEmail(email, {
    redirectTo: `${origin}/auth/callback?redirect_to=/reset-password`,
  });

  if (error) {
    return encodedRedirect(
      'error',
      '/forgot-password',
      'Could not reset password',
    );
  }

  if (callbackUrl) {
    return redirect(callbackUrl);
  }

  return encodedRedirect(
    'success',
    '/forgot-password',
    'Check your email for a link to reset your password.',
  );
};


export const resetPassword = async ({
  password,
  confirmPassword,
}: {
  password: string,
  confirmPassword: string
}): Promise<Result<null>> => {
  if (!password || !confirmPassword) {
    return { success: false, error: 'Password and confirm password are required!' };
  }
  const supabase = await createServerClient();
  if (password !== confirmPassword) {
    return { success: false, error: 'Passwords do not match!' };
  }
  const { error } = await supabase.auth.updateUser({
    password,
  });
  if (error) {
    return { success: false, error: `Password update failed: ${error.message}` };
  }
  return { success: true, data: null };
};


export const resetPasswordFromEmail = async (formData: FormData) => {
   const password = formData.get('password') as string;
   const confirmPassword = formData.get('confirmPassword') as string;
  if (!password || !confirmPassword) {
    encodedRedirect(
      'error',
      '/reset-password',
      'Password and confirm password are required',
    );
  }
  const supabase = await createServerClient();

  if (password !== confirmPassword) {
    encodedRedirect('error', '/reset-password', 'Passwords do not match');
  }

  const { error } = await supabase.auth.updateUser({
    password: password,
  });

  if (error) {
    encodedRedirect('error', '/reset-password', 'Password update failed');
  }

  encodedRedirect('success', '/reset-password', 'Password updated');
};

export const signOut = async (): Promise<Result<null>> => {
  const supabase = await createServerClient();
  const { error } = await supabase.auth.signOut();
  if (error) return { success: false, error: error.message }
  return { success: true, data: null };
};

export const getUser = async (): Promise<Result<User>> => {
  try {
    const supabase = await createServerClient();
    const { data, error } = await supabase.auth.getUser();
    if (error) throw error;
    return { success: true, data: data.user };
  } catch (error) {
    return { success: false, error: 'Could not get user!' };
  }
};