nextjs-hackathon-stack 0.1.30 → 0.1.31

package/template/src/features/todos/__tests__/todos.action.test.ts

@@ -1,11 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 
-const mockInsert = vi.fn();
-const mockUpdate = vi.fn();
-const mockDelete = vi.fn();
-const mockSelectWhere = vi.fn();
 const mockRevalidatePath = vi.fn();
 const mockGetUser = vi.fn();
+const mockFrom = vi.fn();
 
 vi.mock("next/cache", () => ({
   revalidatePath: (path: string): unknown => mockRevalidatePath(path),
@@ -15,22 +12,27 @@ vi.mock("@/shared/lib/supabase/server", () => ({
   createClient: vi.fn(() =>
     Promise.resolve({
       auth: { getUser: mockGetUser },
+      from: mockFrom,
     })
   ),
 }));
 
-vi.mock("@/shared/db", () => ({
-  db: {
-    insert: vi.fn(() => ({ values: mockInsert })),
-    update: vi.fn(() => ({ set: vi.fn(() => ({ where: mockUpdate })) })),
-    delete: vi.fn(() => ({ where: mockDelete })),
-    select: vi.fn(() => ({ from: vi.fn(() => ({ where: mockSelectWhere })) })),
-  },
-}));
-
-vi.mock("@/shared/db/schema", () => ({
-  todos: {},
-}));
+interface QueryResult { data: unknown; error: unknown }
+
+function makeChain(result: QueryResult) {
+  const chain: Record<string, unknown> = {};
+  chain.insert = vi.fn(() => chain);
+  chain.select = vi.fn(() => chain);
+  chain.update = vi.fn(() => chain);
+  chain.delete = vi.fn(() => chain);
+  chain.eq = vi.fn(() => chain);
+  chain.single = vi.fn(() => Promise.resolve(result));
+  chain.then = (
+    onFulfilled: (v: QueryResult) => unknown,
+    onRejected?: (e: unknown) => unknown
+  ) => Promise.resolve(result).then(onFulfilled, onRejected);
+  return chain;
+}
 
 describe("addTodoAction", () => {
   beforeEach(() => {
@@ -48,58 +50,57 @@ describe("addTodoAction", () => {
 
     // Assert
     expect(result.status).toBe("error");
-    expect(mockInsert).not.toHaveBeenCalled();
+    expect(mockFrom).not.toHaveBeenCalled();
   });
 
-  it("retorna error si no hay usuario autenticado", async () => {
+  it("retorna error si el campo title no está presente", async () => {
     // Arrange
-    mockGetUser.mockResolvedValue({ data: { user: null } });
     const { addTodoAction } = await import("../actions/todos.action");
     const fd = new FormData();
-    fd.set("title", "Mi tarea");
 
     // Act
     const result = await addTodoAction(fd);
 
     // Assert
     expect(result.status).toBe("error");
-    expect(mockInsert).not.toHaveBeenCalled();
+    expect(mockFrom).not.toHaveBeenCalled();
   });
 
-  it("inserta la tarea, llama a revalidatePath y retorna success cuando el usuario existe", async () => {
+  it("retorna error si no hay usuario autenticado", async () => {
     // Arrange
-    mockGetUser.mockResolvedValue({ data: { user: { id: "u1" } } });
-    mockInsert.mockResolvedValue(undefined);
+    mockGetUser.mockResolvedValue({ data: { user: null } });
     const { addTodoAction } = await import("../actions/todos.action");
     const fd = new FormData();
-    fd.set("title", "Nueva tarea");
+    fd.set("title", "Mi tarea");
 
     // Act
     const result = await addTodoAction(fd);
 
     // Assert
-    expect(result.status).toBe("success");
-    expect(mockInsert).toHaveBeenCalledWith({ userId: "u1", title: "Nueva tarea" });
-    expect(mockRevalidatePath).toHaveBeenCalledWith("/");
+    expect(result.status).toBe("error");
+    expect(mockFrom).not.toHaveBeenCalled();
   });
 
-  it("retorna error si el campo title no está presente", async () => {
+  it("inserta la tarea, llama a revalidatePath y retorna success cuando el usuario existe", async () => {
     // Arrange
+    mockGetUser.mockResolvedValue({ data: { user: { id: "u1" } } });
+    mockFrom.mockReturnValue(makeChain({ data: null, error: null }));
     const { addTodoAction } = await import("../actions/todos.action");
     const fd = new FormData();
+    fd.set("title", "Nueva tarea");
 
     // Act
     const result = await addTodoAction(fd);
 
     // Assert
-    expect(result.status).toBe("error");
-    expect(mockInsert).not.toHaveBeenCalled();
+    expect(result.status).toBe("success");
+    expect(mockRevalidatePath).toHaveBeenCalledWith("/");
   });
 
-  it("retorna error si la inserción lanza una excepción", async () => {
+  it("retorna error si la inserción falla", async () => {
     // Arrange
     mockGetUser.mockResolvedValue({ data: { user: { id: "u1" } } });
-    mockInsert.mockRejectedValue(new Error("DB error"));
+    mockFrom.mockReturnValue(makeChain({ data: null, error: new Error("DB error") }));
     const { addTodoAction } = await import("../actions/todos.action");
     const fd = new FormData();
     fd.set("title", "Tarea fallida");
@@ -117,9 +118,25 @@ describe("toggleTodoAction", () => {
     vi.clearAllMocks();
   });
 
+  it("retorna error si no hay usuario autenticado", async () => {
+    // Arrange
+    mockGetUser.mockResolvedValue({ data: { user: null } });
+    const { toggleTodoAction } = await import("../actions/todos.action");
+
+    // Act
+    const result = await toggleTodoAction("1");
+
+    // Assert
+    expect(result.status).toBe("error");
+    expect(mockFrom).not.toHaveBeenCalled();
+  });
+
   it("retorna error si la tarea no existe", async () => {
     // Arrange
-    mockSelectWhere.mockResolvedValue([]);
+    mockGetUser.mockResolvedValue({ data: { user: { id: "u1" } } });
+    mockFrom.mockReturnValue(
+      makeChain({ data: null, error: { code: "PGRST116" } })
+    );
     const { toggleTodoAction } = await import("../actions/todos.action");
 
     // Act
@@ -127,13 +144,14 @@ describe("toggleTodoAction", () => {
 
     // Assert
     expect(result.status).toBe("error");
-    expect(mockUpdate).not.toHaveBeenCalled();
   });
 
   it("invierte completed, llama a revalidatePath y retorna success", async () => {
     // Arrange
-    mockSelectWhere.mockResolvedValue([{ id: "1", completed: false }]);
-    mockUpdate.mockResolvedValue(undefined);
+    mockGetUser.mockResolvedValue({ data: { user: { id: "u1" } } });
+    mockFrom
+      .mockReturnValueOnce(makeChain({ data: { completed: false }, error: null }))
+      .mockReturnValueOnce(makeChain({ data: null, error: null }));
     const { toggleTodoAction } = await import("../actions/todos.action");
 
     // Act
@@ -141,13 +159,15 @@ describe("toggleTodoAction", () => {
 
     // Assert
     expect(result.status).toBe("success");
-    expect(mockUpdate).toHaveBeenCalled();
     expect(mockRevalidatePath).toHaveBeenCalledWith("/");
   });
 
-  it("retorna error si la actualización lanza una excepción", async () => {
+  it("retorna error si la actualización falla", async () => {
     // Arrange
-    mockSelectWhere.mockRejectedValue(new Error("DB error"));
+    mockGetUser.mockResolvedValue({ data: { user: { id: "u1" } } });
+    mockFrom
+      .mockReturnValueOnce(makeChain({ data: { completed: true }, error: null }))
+      .mockReturnValueOnce(makeChain({ data: null, error: new Error("DB error") }));
     const { toggleTodoAction } = await import("../actions/todos.action");
 
     // Act
@@ -163,9 +183,23 @@ describe("deleteTodoAction", () => {
     vi.clearAllMocks();
   });
 
+  it("retorna error si no hay usuario autenticado", async () => {
+    // Arrange
+    mockGetUser.mockResolvedValue({ data: { user: null } });
+    const { deleteTodoAction } = await import("../actions/todos.action");
+
+    // Act
+    const result = await deleteTodoAction("1");
+
+    // Assert
+    expect(result.status).toBe("error");
+    expect(mockFrom).not.toHaveBeenCalled();
+  });
+
   it("elimina la tarea, llama a revalidatePath y retorna success", async () => {
     // Arrange
-    mockDelete.mockResolvedValue(undefined);
+    mockGetUser.mockResolvedValue({ data: { user: { id: "u1" } } });
+    mockFrom.mockReturnValue(makeChain({ data: null, error: null }));
     const { deleteTodoAction } = await import("../actions/todos.action");
 
     // Act
@@ -173,13 +207,13 @@ describe("deleteTodoAction", () => {
 
     // Assert
     expect(result.status).toBe("success");
-    expect(mockDelete).toHaveBeenCalled();
     expect(mockRevalidatePath).toHaveBeenCalledWith("/");
   });
 
-  it("retorna error si la eliminación lanza una excepción", async () => {
+  it("retorna error si la eliminación falla", async () => {
     // Arrange
-    mockDelete.mockRejectedValue(new Error("DB error"));
+    mockGetUser.mockResolvedValue({ data: { user: { id: "u1" } } });
+    mockFrom.mockReturnValue(makeChain({ data: null, error: new Error("DB error") }));
     const { deleteTodoAction } = await import("../actions/todos.action");
 
     // Act

package/template/src/features/todos/__tests__/todos.queries.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi } from "vitest";
+
+import { getTodoById, getTodosByUserId } from "../queries/todos.queries";
+
+import type { createClient } from "@/shared/lib/supabase/server";
+
+type Client = Awaited<ReturnType<typeof createClient>>;
+interface QueryResult { data: unknown; error: unknown }
+
+function makeSupabase(result: QueryResult) {
+  const chain: Record<string, unknown> = {};
+  chain.select = vi.fn(() => chain);
+  chain.eq = vi.fn(() => chain);
+  chain.single = vi.fn(() => Promise.resolve(result));
+  chain.then = (
+    onFulfilled: (v: QueryResult) => unknown,
+    onRejected?: (e: unknown) => unknown
+  ) => Promise.resolve(result).then(onFulfilled, onRejected);
+  return { from: vi.fn(() => chain) } as unknown as Client;
+}
+
+describe("getTodosByUserId", () => {
+  it("retorna los todos del usuario cuando la consulta tiene éxito", async () => {
+    // Arrange
+    const todos = [{ id: "1", title: "Tarea", completed: false, user_id: "u1" }];
+    const supabase = makeSupabase({ data: todos, error: null });
+
+    // Act
+    const result = await getTodosByUserId(supabase, "u1");
+
+    // Assert
+    expect(result.data).toEqual(todos);
+    expect(result.error).toBeNull();
+  });
+
+  it("retorna lista vacía cuando el usuario no tiene todos", async () => {
+    // Arrange
+    const supabase = makeSupabase({ data: [], error: null });
+
+    // Act
+    const result = await getTodosByUserId(supabase, "u1");
+
+    // Assert
+    expect(result.data).toEqual([]);
+    expect(result.error).toBeNull();
+  });
+
+  it("retorna error cuando falla la consulta", async () => {
+    // Arrange
+    const dbError = new Error("DB error");
+    const supabase = makeSupabase({ data: null, error: dbError });
+
+    // Act
+    const result = await getTodosByUserId(supabase, "u1");
+
+    // Assert
+    expect(result.data).toBeNull();
+    expect(result.error).toBe(dbError);
+  });
+});
+
+describe("getTodoById", () => {
+  it("retorna el todo cuando existe y pertenece al usuario", async () => {
+    // Arrange
+    const todo = { id: "1", completed: false };
+    const supabase = makeSupabase({ data: todo, error: null });
+
+    // Act
+    const result = await getTodoById(supabase, "1", "u1");
+
+    // Assert
+    expect(result.data).toEqual(todo);
+    expect(result.error).toBeNull();
+  });
+
+  it("retorna error cuando el todo no existe", async () => {
+    // Arrange
+    const dbError = { code: "PGRST116" };
+    const supabase = makeSupabase({ data: null, error: dbError });
+
+    // Act
+    const result = await getTodoById(supabase, "non-existent", "u1");
+
+    // Assert
+    expect(result.data).toBeNull();
+    expect(result.error).toEqual(dbError);
+  });
+
+  it("retorna error cuando falla la consulta", async () => {
+    // Arrange
+    const dbError = new Error("DB error");
+    const supabase = makeSupabase({ data: null, error: dbError });
+
+    // Act
+    const result = await getTodoById(supabase, "1", "u1");
+
+    // Assert
+    expect(result.data).toBeNull();
+    expect(result.error).toBe(dbError);
+  });
+});

package/template/src/features/todos/actions/todos.action.ts

@@ -1,10 +1,8 @@
 "use server";
 
-import { eq } from "drizzle-orm";
 import { revalidatePath } from "next/cache";
 
-import { db } from "@/shared/db";
-import { todos } from "@/shared/db/schema";
+import { getTodoById } from "@/features/todos/queries/todos.queries";
 import type { ActionResult } from "@/shared/lib/action-result";
 import { createClient } from "@/shared/lib/supabase/server";
 
@@ -20,34 +18,50 @@ export async function addTodoAction(formData: FormData): Promise<ActionResult> {
   } = await supabase.auth.getUser();
   if (!user) return { status: "error", message: "No autenticado" };
 
-  try {
-    await db.insert(todos).values({ userId: user.id, title: title.trim() });
-    revalidatePath("/");
-    return { status: "success", message: "Tarea agregada" };
-  } catch {
-    return { status: "error", message: "Error al agregar la tarea" };
-  }
+  const { error } = await supabase
+    .from("todos")
+    .insert({ user_id: user.id, title: title.trim() });
+  if (error) return { status: "error", message: "Error al agregar la tarea" };
+
+  revalidatePath("/");
+  return { status: "success", message: "Tarea agregada" };
 }
 
 export async function toggleTodoAction(id: string): Promise<ActionResult> {
-  try {
-    const [todo] = await db.select().from(todos).where(eq(todos.id, id));
-    if (!todo) return { status: "error", message: "Tarea no encontrada" };
-
-    await db.update(todos).set({ completed: !todo.completed }).where(eq(todos.id, id));
-    revalidatePath("/");
-    return { status: "success", message: "Tarea actualizada" };
-  } catch {
-    return { status: "error", message: "Error al actualizar la tarea" };
-  }
+  const supabase = await createClient();
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+  if (!user) return { status: "error", message: "No autenticado" };
+
+  const { data: todo, error: fetchError } = await getTodoById(supabase, id, user.id);
+  if (fetchError ?? !todo) return { status: "error", message: "Tarea no encontrada" };
+
+  const { error } = await supabase
+    .from("todos")
+    .update({ completed: !todo.completed })
+    .eq("id", id)
+    .eq("user_id", user.id);
+  if (error) return { status: "error", message: "Error al actualizar la tarea" };
+
+  revalidatePath("/");
+  return { status: "success", message: "Tarea actualizada" };
 }
 
 export async function deleteTodoAction(id: string): Promise<ActionResult> {
-  try {
-    await db.delete(todos).where(eq(todos.id, id));
-    revalidatePath("/");
-    return { status: "success", message: "Tarea eliminada" };
-  } catch {
-    return { status: "error", message: "Error al eliminar la tarea" };
-  }
+  const supabase = await createClient();
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+  if (!user) return { status: "error", message: "No autenticado" };
+
+  const { error } = await supabase
+    .from("todos")
+    .delete()
+    .eq("id", id)
+    .eq("user_id", user.id);
+  if (error) return { status: "error", message: "Error al eliminar la tarea" };
+
+  revalidatePath("/");
+  return { status: "success", message: "Tarea eliminada" };
 }

package/template/src/features/todos/queries/todos.queries.ts

@@ -0,0 +1,16 @@
+import type { createClient } from "@/shared/lib/supabase/server";
+
+type Client = Awaited<ReturnType<typeof createClient>>;
+
+export async function getTodosByUserId(supabase: Client, userId: string) {
+  return supabase.from("todos").select("*").eq("user_id", userId);
+}
+
+export async function getTodoById(supabase: Client, id: string, userId: string) {
+  return supabase
+    .from("todos")
+    .select("completed")
+    .eq("id", id)
+    .eq("user_id", userId)
+    .single();
+}

package/template/src/shared/lib/supabase/middleware.ts

@@ -4,7 +4,6 @@ import { NextResponse, type NextRequest } from "next/server";
 export async function updateSession(request: NextRequest) {
   let supabaseResponse = NextResponse.next({ request });
 
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
   const supabase = createServerClient(
     process.env.NEXT_PUBLIC_SUPABASE_URL ?? "",
     process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY ?? "",

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

@@ -4,7 +4,6 @@ import { cookies } from "next/headers";
 export async function createClient() {
   const cookieStore = await cookies();
 
-  // eslint-disable-next-line @typescript-eslint/no-deprecated
   return createServerClient(
     process.env.NEXT_PUBLIC_SUPABASE_URL ?? "",
     process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY ?? "",