@create-lft-app/nextjs 1.0.2 → 3.0.0

package/template/src/lib/supabase/proxy.ts

@@ -0,0 +1,67 @@
+import { createServerClient, type CookieOptions } from '@supabase/ssr'
+import { NextResponse, type NextRequest } from 'next/server'
+
+const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL
+const supabaseKey = process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_DEFAULT_KEY
+
+type CookieToSet = {
+  name: string
+  value: string
+  options: CookieOptions
+}
+
+export async function updateSession(request: NextRequest) {
+  let supabaseResponse = NextResponse.next({
+    request: {
+      headers: request.headers,
+    },
+  })
+
+  const supabase = createServerClient(
+    supabaseUrl!,
+    supabaseKey!,
+    {
+      cookies: {
+        getAll() {
+          return request.cookies.getAll()
+        },
+        setAll(cookiesToSet: CookieToSet[]) {
+          cookiesToSet.forEach(({ name, value }) =>
+            request.cookies.set(name, value)
+          )
+          supabaseResponse = NextResponse.next({
+            request,
+          })
+          cookiesToSet.forEach(({ name, value, options }) =>
+            supabaseResponse.cookies.set(name, value, options)
+          )
+        },
+      },
+    }
+  )
+
+  // Refresh session if expired
+  const { data: { user } } = await supabase.auth.getUser()
+
+  // Define route protection
+  const pathname = request.nextUrl.pathname
+
+  const protectedPaths = ['/dashboard', '/users', '/settings', '/reports']
+  const publicOnlyPaths = ['/login', '/register']
+
+  const isProtectedPath = protectedPaths.some((path) => pathname.startsWith(path))
+  const isPublicOnlyPath = publicOnlyPaths.some((path) => pathname.startsWith(path))
+
+  // Redirect logic
+  if (!user && isProtectedPath) {
+    const redirectUrl = new URL('/login', request.url)
+    redirectUrl.searchParams.set('redirectTo', pathname)
+    return NextResponse.redirect(redirectUrl)
+  }
+
+  if (user && isPublicOnlyPath) {
+    return NextResponse.redirect(new URL('/dashboard', request.url))
+  }
+
+  return supabaseResponse
+}

package/template/src/lib/supabase/server.ts

@@ -1,6 +1,8 @@
-import { createServerClient } from '@supabase/ssr'
+import { createServerClient, type CookieOptions } from '@supabase/ssr'
 import { cookies } from 'next/headers'
-import type { CookieOptions } from '@supabase/ssr'
+
+const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL
+const supabaseKey = process.env.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_DEFAULT_KEY
 
 type CookieToSet = {
   name: string
@@ -12,8 +14,8 @@ export async function createClient() {
   const cookieStore = await cookies()
 
   return createServerClient(
-    process.env.NEXT_PUBLIC_SUPABASE_URL!,
-    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+    supabaseUrl!,
+    supabaseKey!,
     {
       cookies: {
         getAll() {

package/template/src/lib/supabase/types.ts

@@ -0,0 +1,53 @@
+export type Json =
+  | string
+  | number
+  | boolean
+  | null
+  | { [key: string]: Json | undefined }
+  | Json[]
+
+export interface Database {
+  public: {
+    Tables: {
+      users: {
+        Row: {
+          id: string
+          email: string
+          name: string
+          role: 'admin' | 'user' | 'viewer'
+          avatar_url: string | null
+          created_at: string
+          updated_at: string
+        }
+        Insert: {
+          id?: string
+          email: string
+          name: string
+          role?: 'admin' | 'user' | 'viewer'
+          avatar_url?: string | null
+          created_at?: string
+          updated_at?: string
+        }
+        Update: {
+          id?: string
+          email?: string
+          name?: string
+          role?: 'admin' | 'user' | 'viewer'
+          avatar_url?: string | null
+          created_at?: string
+          updated_at?: string
+        }
+        Relationships: []
+      }
+    }
+    Views: {
+      [_ in never]: never
+    }
+    Functions: {
+      [_ in never]: never
+    }
+    Enums: {
+      user_role: 'admin' | 'user' | 'viewer'
+    }
+  }
+}

package/template/src/lib/validations/common.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod'
+
+// Common reusable schemas
+
+export const emailSchema = z
+  .string()
+  .min(1, 'El email es requerido')
+  .email('Email inválido')
+
+export const passwordSchema = z
+  .string()
+  .min(1, 'La contraseña es requerida')
+  .min(6, 'La contraseña debe tener al menos 6 caracteres')
+  .max(100, 'La contraseña no puede tener más de 100 caracteres')
+
+export const phoneSchema = z
+  .string()
+  .min(1, 'El teléfono es requerido')
+  .regex(/^[+]?[\d\s-()]+$/, 'Teléfono inválido')
+  .min(10, 'El teléfono debe tener al menos 10 dígitos')
+
+export const urlSchema = z
+  .string()
+  .url('URL inválida')
+  .or(z.literal(''))
+
+export const uuidSchema = z
+  .string()
+  .uuid('ID inválido')
+
+export const dateSchema = z
+  .string()
+  .datetime({ message: 'Fecha inválida' })
+
+export const positiveNumberSchema = z
+  .number()
+  .positive('El número debe ser positivo')
+
+export const nonNegativeNumberSchema = z
+  .number()
+  .nonnegative('El número no puede ser negativo')
+
+export const percentageSchema = z
+  .number()
+  .min(0, 'El porcentaje no puede ser menor a 0')
+  .max(100, 'El porcentaje no puede ser mayor a 100')
+
+export const currencySchema = z
+  .number()
+  .nonnegative('El monto no puede ser negativo')
+  .multipleOf(0.01, 'El monto debe tener máximo 2 decimales')
+
+// Pagination schemas
+export const paginationSchema = z.object({
+  page: z.number().int().positive().default(1),
+  pageSize: z.number().int().positive().max(100).default(10),
+})
+
+export const sortSchema = z.object({
+  sortBy: z.string().optional(),
+  sortOrder: z.enum(['asc', 'desc']).default('asc'),
+})
+
+// Search schema
+export const searchSchema = z.object({
+  query: z.string().optional(),
+})
+
+// Combined query params schema
+export const queryParamsSchema = paginationSchema.merge(sortSchema).merge(searchSchema)
+
+export type PaginationInput = z.infer<typeof paginationSchema>
+export type SortInput = z.infer<typeof sortSchema>
+export type SearchInput = z.infer<typeof searchSchema>
+export type QueryParamsInput = z.infer<typeof queryParamsSchema>

package/template/src/lib/validations/index.ts

@@ -0,0 +1,20 @@
+export {
+  emailSchema,
+  passwordSchema,
+  phoneSchema,
+  urlSchema,
+  uuidSchema,
+  dateSchema,
+  positiveNumberSchema,
+  nonNegativeNumberSchema,
+  percentageSchema,
+  currencySchema,
+  paginationSchema,
+  sortSchema,
+  searchSchema,
+  queryParamsSchema,
+  type PaginationInput,
+  type SortInput,
+  type SearchInput,
+  type QueryParamsInput,
+} from './common'

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

@@ -1,12 +1,59 @@
 'use server'
 
+import { createClient } from '@/lib/supabase/server'
 import { redirect } from 'next/navigation'
+import { loginSchema, registerSchema, type LoginInput, type RegisterInput } from '../schemas/auth.schema'
+
+export async function login(input: LoginInput) {
+  const parsed = loginSchema.safeParse(input)
+
+  if (!parsed.success) {
+    return { error: parsed.error.errors[0].message }
+  }
+
+  const supabase = await createClient()
+
+  const { error } = await supabase.auth.signInWithPassword({
+    email: parsed.data.email,
+    password: parsed.data.password,
+  })
+
+  if (error) {
+    return { error: error.message }
+  }
+
+  redirect('/dashboard')
+}
+
+export async function register(input: RegisterInput) {
+  const parsed = registerSchema.safeParse(input)
+
+  if (!parsed.success) {
+    return { error: parsed.error.errors[0].message }
+  }
+
+  const supabase = await createClient()
+
+  const { error } = await supabase.auth.signUp({
+    email: parsed.data.email,
+    password: parsed.data.password,
+  })
+
+  if (error) {
+    return { error: error.message }
+  }
+
+  redirect('/dashboard')
+}
 
 export async function logout() {
-  // TODO: Implementar con Supabase
-  // const supabase = await createClient()
-  // await supabase.auth.signOut()
+  const supabase = await createClient()
+  await supabase.auth.signOut()
   redirect('/login')
 }
 
-export const logoutAction = logout
+export async function getUser() {
+  const supabase = await createClient()
+  const { data: { user } } = await supabase.auth.getUser()
+  return user
+}

package/template/src/modules/auth/components/login-form.tsx

@@ -0,0 +1,68 @@
+'use client'
+
+import { useForm } from 'react-hook-form'
+import { zodResolver } from '@hookform/resolvers/zod'
+import { toast } from 'sonner'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Label } from '@/components/ui/label'
+import { useAuth } from '../hooks/useAuth'
+import { loginSchema, type LoginInput } from '../schemas/auth.schema'
+
+export function LoginForm() {
+  const { login, isLoggingIn } = useAuth()
+
+  const form = useForm<LoginInput>({
+    resolver: zodResolver(loginSchema),
+    defaultValues: {
+      email: '',
+      password: '',
+    },
+  })
+
+  async function onSubmit(data: LoginInput) {
+    const result = await login(data)
+
+    if (result?.error) {
+      toast.error(result.error)
+    }
+  }
+
+  return (
+    <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-4">
+      <div className="space-y-2">
+        <Label htmlFor="email">Email</Label>
+        <Input
+          id="email"
+          type="email"
+          placeholder="tu@email.com"
+          {...form.register('email')}
+        />
+        {form.formState.errors.email && (
+          <p className="text-sm text-destructive">
+            {form.formState.errors.email.message}
+          </p>
+        )}
+      </div>
+
+      <div className="space-y-2">
+        <Label htmlFor="password">Contraseña</Label>
+        <Input
+          id="password"
+          type="password"
+          placeholder="••••••••"
+          {...form.register('password')}
+        />
+        {form.formState.errors.password && (
+          <p className="text-sm text-destructive">
+            {form.formState.errors.password.message}
+          </p>
+        )}
+      </div>
+
+      <Button type="submit" className="w-full" disabled={isLoggingIn}>
+        {isLoggingIn ? 'Iniciando sesión...' : 'Iniciar sesión'}
+      </Button>
+    </form>
+  )
+}

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

@@ -0,0 +1,38 @@
+'use client'
+
+import { useShallow } from 'zustand/react/shallow'
+import { useAuthStore } from '../stores/useAuthStore'
+import { useAuthQueries } from './useAuthQueries'
+import { useAuthMutations } from './useAuthMutations'
+
+/**
+ * Hook unificado para autenticación.
+ * Los componentes SOLO deben importar este hook, nunca useAuthQueries o useAuthMutations directamente.
+ */
+export function useAuth() {
+  const state = useAuthStore(useShallow((s) => s.state))
+  const actions = useAuthStore(useShallow((s) => s.actions))
+
+  const queries = useAuthQueries()
+  const mutations = useAuthMutations()
+
+  return {
+    // State from store (UI state)
+    ...state,
+    ...actions,
+
+    // Queries
+    user: queries.user,
+    session: queries.session,
+    isAuthenticated: queries.isAuthenticated,
+    isLoadingUser: queries.isLoading,
+
+    // Mutations
+    login: mutations.login,
+    register: mutations.register,
+    logout: mutations.logout,
+    isLoggingIn: mutations.isLoggingIn,
+    isRegistering: mutations.isRegistering,
+    isLoggingOut: mutations.isLoggingOut,
+  }
+}

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

@@ -0,0 +1,43 @@
+'use client'
+
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+import { login, register, logout } from '../actions/auth-actions'
+import { authKeys } from './useAuthQueries'
+import type { LoginInput, RegisterInput } from '../schemas/auth.schema'
+
+export function useAuthMutations() {
+  const queryClient = useQueryClient()
+
+  const loginMutation = useMutation({
+    mutationFn: (input: LoginInput) => login(input),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: authKeys.all })
+    },
+  })
+
+  const registerMutation = useMutation({
+    mutationFn: (input: RegisterInput) => register(input),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: authKeys.all })
+    },
+  })
+
+  const logoutMutation = useMutation({
+    mutationFn: () => logout(),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: authKeys.all })
+      queryClient.clear()
+    },
+  })
+
+  return {
+    login: loginMutation.mutateAsync,
+    register: registerMutation.mutateAsync,
+    logout: logoutMutation.mutateAsync,
+    isLoggingIn: loginMutation.isPending,
+    isRegistering: registerMutation.isPending,
+    isLoggingOut: logoutMutation.isPending,
+    loginError: loginMutation.error,
+    registerError: registerMutation.error,
+  }
+}

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

@@ -0,0 +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,
+  }
+}

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

@@ -0,0 +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'

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

@@ -0,0 +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>

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

@@ -0,0 +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,
+      })),
+  },
+}))

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

@@ -0,0 +1,94 @@
+'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
+}