@create-lft-app/nextjs 3.1.0 → 3.2.0

package/template/src/modules/auth/hooks/useAuthQueries.ts

@@ -1,43 +1,43 @@
-'use client'
-
-import { useQuery } from '@tanstack/react-query'
-import { createClient } from '@/lib/supabase/client'
-
-export const authKeys = {
-  all: ['auth'] as const,
-  user: () => [...authKeys.all, 'user'] as const,
-  session: () => [...authKeys.all, 'session'] as const,
-}
-
-export function useAuthQueries() {
-  const supabase = createClient()
-
-  const userQuery = useQuery({
-    queryKey: authKeys.user(),
-    queryFn: async () => {
-      const { data: { user }, error } = await supabase.auth.getUser()
-      if (error) throw error
-      return user
-    },
-    staleTime: 1000 * 60 * 5, // 5 minutos
-  })
-
-  const sessionQuery = useQuery({
-    queryKey: authKeys.session(),
-    queryFn: async () => {
-      const { data: { session }, error } = await supabase.auth.getSession()
-      if (error) throw error
-      return session
-    },
-    staleTime: 1000 * 60 * 5,
-  })
-
-  return {
-    user: userQuery.data,
-    session: sessionQuery.data,
-    isLoading: userQuery.isLoading || sessionQuery.isLoading,
-    isAuthenticated: !!userQuery.data,
-    userQuery,
-    sessionQuery,
-  }
-}
+'use client'
+
+import { useQuery } from '@tanstack/react-query'
+import { createClient } from '@/lib/supabase/client'
+
+export const authKeys = {
+  all: ['auth'] as const,
+  user: () => [...authKeys.all, 'user'] as const,
+  session: () => [...authKeys.all, 'session'] as const,
+}
+
+export function useAuthQueries() {
+  const supabase = createClient()
+
+  const userQuery = useQuery({
+    queryKey: authKeys.user(),
+    queryFn: async () => {
+      const { data: { user }, error } = await supabase.auth.getUser()
+      if (error) throw error
+      return user
+    },
+    staleTime: 1000 * 60 * 5, // 5 minutos
+  })
+
+  const sessionQuery = useQuery({
+    queryKey: authKeys.session(),
+    queryFn: async () => {
+      const { data: { session }, error } = await supabase.auth.getSession()
+      if (error) throw error
+      return session
+    },
+    staleTime: 1000 * 60 * 5,
+  })
+
+  return {
+    user: userQuery.data,
+    session: sessionQuery.data,
+    isLoading: userQuery.isLoading || sessionQuery.isLoading,
+    isAuthenticated: !!userQuery.data,
+    userQuery,
+    sessionQuery,
+  }
+}

package/template/src/modules/auth/index.ts

@@ -1,12 +1,12 @@
-// Components
-export { LoginForm } from './components/login-form'
-
-// Hooks - Solo exportar el hook unificado
-export { useAuth } from './hooks/useAuth'
-
-// Schemas
-export { loginSchema, registerSchema } from './schemas/auth.schema'
-export type { LoginInput, RegisterInput } from './schemas/auth.schema'
-
-// Actions
-export { login, register, logout, getUser } from './actions/auth-actions'
+// Components
+export { LoginForm } from './components/login-form'
+
+// Hooks - Solo exportar el hook unificado
+export { useAuth } from './hooks/useAuth'
+
+// Schemas
+export { loginSchema, registerSchema } from './schemas/auth.schema'
+export type { LoginInput, RegisterInput } from './schemas/auth.schema'
+
+// Actions
+export { login, register, logout, getUser } from './actions/auth-actions'

package/template/src/modules/auth/schemas/auth.schema.ts

@@ -1,32 +1,32 @@
-import { z } from 'zod'
-
-export const loginSchema = z.object({
-  email: z
-    .string()
-    .min(1, 'El email es requerido')
-    .email('Email inválido'),
-  password: z
-    .string()
-    .min(1, 'La contraseña es requerida')
-    .min(6, 'La contraseña debe tener al menos 6 caracteres'),
-})
-
-export const registerSchema = z.object({
-  email: z
-    .string()
-    .min(1, 'El email es requerido')
-    .email('Email inválido'),
-  password: z
-    .string()
-    .min(1, 'La contraseña es requerida')
-    .min(6, 'La contraseña debe tener al menos 6 caracteres'),
-  confirmPassword: z
-    .string()
-    .min(1, 'Confirma tu contraseña'),
-}).refine((data) => data.password === data.confirmPassword, {
-  message: 'Las contraseñas no coinciden',
-  path: ['confirmPassword'],
-})
-
-export type LoginInput = z.infer<typeof loginSchema>
-export type RegisterInput = z.infer<typeof registerSchema>
+import { z } from 'zod'
+
+export const loginSchema = z.object({
+  email: z
+    .string()
+    .min(1, 'El email es requerido')
+    .email('Email inválido'),
+  password: z
+    .string()
+    .min(1, 'La contraseña es requerida')
+    .min(6, 'La contraseña debe tener al menos 6 caracteres'),
+})
+
+export const registerSchema = z.object({
+  email: z
+    .string()
+    .min(1, 'El email es requerido')
+    .email('Email inválido'),
+  password: z
+    .string()
+    .min(1, 'La contraseña es requerida')
+    .min(6, 'La contraseña debe tener al menos 6 caracteres'),
+  confirmPassword: z
+    .string()
+    .min(1, 'Confirma tu contraseña'),
+}).refine((data) => data.password === data.confirmPassword, {
+  message: 'Las contraseñas no coinciden',
+  path: ['confirmPassword'],
+})
+
+export type LoginInput = z.infer<typeof loginSchema>
+export type RegisterInput = z.infer<typeof registerSchema>

package/template/src/modules/auth/stores/useAuthStore.ts

@@ -1,37 +1,37 @@
-import { create } from 'zustand'
-import type { User } from '@supabase/supabase-js'
-
-interface AuthState {
-  state: {
-    user: User | null
-    isLoading: boolean
-  }
-  actions: {
-    setUser: (user: User | null) => void
-    setLoading: (isLoading: boolean) => void
-    reset: () => void
-  }
-}
-
-const initialState = {
-  user: null,
-  isLoading: true,
-}
-
-export const useAuthStore = create<AuthState>()((set) => ({
-  state: initialState,
-  actions: {
-    setUser: (user) =>
-      set((state) => ({
-        state: { ...state.state, user },
-      })),
-    setLoading: (isLoading) =>
-      set((state) => ({
-        state: { ...state.state, isLoading },
-      })),
-    reset: () =>
-      set(() => ({
-        state: initialState,
-      })),
-  },
-}))
+import { create } from 'zustand'
+import type { User } from '@supabase/supabase-js'
+
+interface AuthState {
+  state: {
+    user: User | null
+    isLoading: boolean
+  }
+  actions: {
+    setUser: (user: User | null) => void
+    setLoading: (isLoading: boolean) => void
+    reset: () => void
+  }
+}
+
+const initialState = {
+  user: null,
+  isLoading: true,
+}
+
+export const useAuthStore = create<AuthState>()((set) => ({
+  state: initialState,
+  actions: {
+    setUser: (user) =>
+      set((state) => ({
+        state: { ...state.state, user },
+      })),
+    setLoading: (isLoading) =>
+      set((state) => ({
+        state: { ...state.state, isLoading },
+      })),
+    reset: () =>
+      set(() => ({
+        state: initialState,
+      })),
+  },
+}))

package/template/src/modules/users/actions/users-actions.ts

@@ -1,94 +1,166 @@
-'use server'
-
-import { createClient } from '@/lib/supabase/server'
-import { createUserSchema, updateUserSchema, type CreateUserInput, type UpdateUserInput } from '../schemas/users.schema'
-
-export async function getUsers() {
-  const supabase = await createClient()
-  const { data: { user } } = await supabase.auth.getUser()
-
-  if (!user) throw new Error('Unauthorized')
-
-  const { data, error } = await supabase
-    .from('users')
-    .select('*')
-    .order('created_at', { ascending: false })
-
-  if (error) throw error
-  return data
-}
-
-export async function getUserById(id: string) {
-  const supabase = await createClient()
-  const { data: { user } } = await supabase.auth.getUser()
-
-  if (!user) throw new Error('Unauthorized')
-
-  const { data, error } = await supabase
-    .from('users')
-    .select('*')
-    .eq('id', id)
-    .single()
-
-  if (error) throw error
-  return data
-}
-
-export async function createUser(input: CreateUserInput) {
-  const parsed = createUserSchema.safeParse(input)
-
-  if (!parsed.success) {
-    throw new Error(parsed.error.errors[0].message)
-  }
-
-  const supabase = await createClient()
-  const { data: { user } } = await supabase.auth.getUser()
-
-  if (!user) throw new Error('Unauthorized')
-
-  const { data, error } = await supabase
-    .from('users')
-    .insert(parsed.data)
-    .select()
-    .single()
-
-  if (error) throw error
-  return data
-}
-
-export async function updateUser(id: string, input: UpdateUserInput) {
-  const parsed = updateUserSchema.safeParse(input)
-
-  if (!parsed.success) {
-    throw new Error(parsed.error.errors[0].message)
-  }
-
-  const supabase = await createClient()
-  const { data: { user } } = await supabase.auth.getUser()
-
-  if (!user) throw new Error('Unauthorized')
-
-  const { data, error } = await supabase
-    .from('users')
-    .update(parsed.data)
-    .eq('id', id)
-    .select()
-    .single()
-
-  if (error) throw error
-  return data
-}
-
-export async function deleteUser(id: string) {
-  const supabase = await createClient()
-  const { data: { user } } = await supabase.auth.getUser()
-
-  if (!user) throw new Error('Unauthorized')
-
-  const { error } = await supabase
-    .from('users')
-    .delete()
-    .eq('id', id)
-
-  if (error) throw error
-}
+'use server'
+
+import { createClient } from '@/lib/supabase/server'
+import { createAdminClient } from '@/lib/supabase/admin'
+import {
+  createAuthUserSchema,
+  updateAuthUserSchema,
+  type CreateAuthUserInput,
+  type UpdateAuthUserInput,
+} from '../schemas/users.schema'
+import { mapAuthUserToUser, mapAuthUsersToUsers } from '../utils/user-mapper'
+
+/**
+ * Obtiene todos los usuarios desde auth.users
+ */
+export async function getUsers() {
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) throw new Error('Unauthorized')
+
+  const adminClient = createAdminClient()
+  const { data, error } = await adminClient.auth.admin.listUsers()
+
+  if (error) throw error
+
+  return mapAuthUsersToUsers(data.users)
+}
+
+/**
+ * Obtiene un usuario por ID desde auth.users
+ */
+export async function getUserById(id: string) {
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) throw new Error('Unauthorized')
+
+  const adminClient = createAdminClient()
+  const { data, error } = await adminClient.auth.admin.getUserById(id)
+
+  if (error) throw error
+
+  return mapAuthUserToUser(data.user)
+}
+
+/**
+ * Crea un nuevo usuario en auth.users
+ */
+export async function createUser(input: CreateAuthUserInput) {
+  const parsed = createAuthUserSchema.safeParse(input)
+
+  if (!parsed.success) {
+    throw new Error(parsed.error.errors[0].message)
+  }
+
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) throw new Error('Unauthorized')
+
+  const adminClient = createAdminClient()
+
+  const { data, error } = await adminClient.auth.admin.createUser({
+    email: parsed.data.email,
+    password: parsed.data.password,
+    email_confirm: !parsed.data.send_invite,
+    app_metadata: {
+      role: parsed.data.role,
+    },
+    user_metadata: {
+      name: parsed.data.name,
+      avatar_url: parsed.data.avatar_url ?? null,
+    },
+  })
+
+  if (error) throw error
+
+  // Enviar email de invitación si se solicita y no se proporcionó password
+  if (parsed.data.send_invite && !parsed.data.password) {
+    await adminClient.auth.admin.inviteUserByEmail(parsed.data.email)
+  }
+
+  return mapAuthUserToUser(data.user)
+}
+
+/**
+ * Actualiza un usuario en auth.users
+ */
+export async function updateUser(id: string, input: UpdateAuthUserInput) {
+  const parsed = updateAuthUserSchema.safeParse(input)
+
+  if (!parsed.success) {
+    throw new Error(parsed.error.errors[0].message)
+  }
+
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) throw new Error('Unauthorized')
+
+  const adminClient = createAdminClient()
+
+  // Obtener usuario actual para merge de metadata
+  const { data: currentUser, error: fetchError } = await adminClient.auth.admin.getUserById(id)
+
+  if (fetchError) throw fetchError
+  if (!currentUser.user) throw new Error('User not found')
+
+  const updatePayload: Parameters<typeof adminClient.auth.admin.updateUserById>[1] = {}
+
+  if (parsed.data.email) {
+    updatePayload.email = parsed.data.email
+  }
+
+  if (parsed.data.password) {
+    updatePayload.password = parsed.data.password
+  }
+
+  // Merge app_metadata (solo role)
+  if (parsed.data.role) {
+    updatePayload.app_metadata = {
+      ...currentUser.user.app_metadata,
+      role: parsed.data.role,
+    }
+  }
+
+  // Merge user_metadata
+  const hasUserMetadataChanges =
+    parsed.data.name !== undefined ||
+    parsed.data.avatar_url !== undefined
+
+  if (hasUserMetadataChanges) {
+    updatePayload.user_metadata = {
+      ...currentUser.user.user_metadata,
+      ...(parsed.data.name !== undefined && { name: parsed.data.name }),
+      ...(parsed.data.avatar_url !== undefined && { avatar_url: parsed.data.avatar_url }),
+    }
+  }
+
+  const { data, error } = await adminClient.auth.admin.updateUserById(id, updatePayload)
+
+  if (error) throw error
+
+  return mapAuthUserToUser(data.user)
+}
+
+/**
+ * Elimina un usuario de auth.users
+ */
+export async function deleteUser(id: string) {
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+
+  if (!user) throw new Error('Unauthorized')
+
+  // Prevenir auto-eliminación
+  if (user.id === id) {
+    throw new Error('No puedes eliminar tu propio usuario')
+  }
+
+  const adminClient = createAdminClient()
+  const { error } = await adminClient.auth.admin.deleteUser(id)
+
+  if (error) throw error
+}