feat: share todo with email

.env

@@ -0,0 +1 @@
+EMAIL_SERVICE_SECRET_TOKEN=a470af17-4371-4362-8b51-335c243ee5eb

README.md

@@ -1,4 +1,4 @@
-# Deno v2 Todo API
+# Deno v2 Todo API :beers:
 
 Battle testing Deno v2 with a simple REST API for managing todos.
 
@@ -27,6 +27,7 @@ deno run test
 - GET /api/todos - Retrieves all todos.
 - GET /api/todos/:id - Retrieves a specific todo by ID.
 - POST /api/todos - Creates a new todo
+- POST /api/todos/:id/shar - Shares an existing todo
 - PUT /api/todos - Creates a new todo.
 - PATCH /api/todos/:id - Updates a specific todo by ID.
 - DELETE /api/todos/:id - Archives a specific todo by ID.

src/controllers/post.ts

@@ -2,11 +2,78 @@ import z from "https://deno.land/x/[email protected]/index.ts";
 import { MemoDatabase, TodoSchema } from "../database.ts";
 import { respond } from "../utilities.ts";
 
+const sendEmails = (todo: z.infer<typeof TodoSchema>, sharedWith: string[]) => {
+  // await emailService.send({
+  //   to: sharedWith,
+  //   subject: `Todo shared with you: ${todo.text}`,
+  //   body: `You have been shared a todo: ${todo.text}.`,
+  // });
+
+  const token = Deno.env.get("EMAIL_SERVICE_SECRET_TOKEN");
+
+  if (!token) {
+    throw new Error("Email service token is not set");
+  }
+
+  console.log(`Sending email with token: ${token}`);
+  console.log(`Sending emails to: ${sharedWith.join(", ")}`);
+  console.log(`Todo details: ${JSON.stringify(todo)}`);
+  return Promise.resolve();
+};
+
+const handleShare = async (
+  req: Request,
+  dbClient: MemoDatabase,
+  validatedBody: z.infer<typeof TodoSchema>
+): Promise<Response> => {
+  const pattern = new URLPattern({ pathname: "/api/todos/:id/share" });
+  const match = pattern.exec(req.url);
+  const id = Number(match?.pathname.groups.id);
+
+  if (Number.isNaN(id)) {
+    return respond({ error: "Invalid id" }, 400);
+  }
+
+  try {
+    const existingTodo = dbClient.todos.getById(id);
+    if (!existingTodo) {
+      return respond({ error: "Todo not found" }, 404);
+    }
+
+    // Important: Check that todo hasn't been shared with the same user
+
+    const updatedTodo = dbClient.todos.update(id, {
+      ...existingTodo,
+      sharedWith: validatedBody.sharedWith,
+    });
+
+    if (!updatedTodo) {
+      return respond({ error: "Todo not found or cannot be updated" }, 404);
+    }
+
+    await sendEmails(updatedTodo, updatedTodo.sharedWith!);
+    return respond(updatedTodo);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return respond({ error: "Invalid data", issues: error.errors }, 400);
+    }
+    return respond({ error: "Unexpected error", issues: error }, 400);
+  }
+};
+
 export const handlePost = async (req: Request, dbClient: MemoDatabase): Promise<Response> => {
   try {
     const body = await req.json();
     const validatedBody = TodoSchema.parse(body);
 
+    const url = new URL(req.url);
+    const { pathname } = url;
+
+    if (pathname.endsWith("/share")) {
+      const result = await handleShare(req, dbClient, validatedBody);
+      return result;
+    }
+
     const newTodo = dbClient.todos.add(validatedBody);
     return respond(newTodo);
   } catch (error) {

src/database.ts

@@ -8,6 +8,7 @@ export const TodoSchema = z.object({
   createdAt: z.string().nullish(),
   updatedAt: z.string().nullish(),
   archivedAt: z.string().nullish(),
+  sharedWith: z.array(z.string()).nullish(),
 });
 
 export type Todo = z.infer<typeof TodoSchema>;
@@ -44,10 +45,10 @@ class Todos {
 
   getById(id: number): Todo | undefined {
     if (!this.isSelectableAndMutable(id)) {
-      return undefined
+      return undefined;
     }
 
-    return { id, ...this.todos[id] };
+    return this.todos[id];
   }
 
   add(todo: Todo): Todo {
@@ -57,14 +58,18 @@ class Todos {
     return newTodo;
   }
 
-  update(id: number, todo: Todo): Todo | undefined {
-    if (!this.isSelectableAndMutable(id)) {
-      return undefined
+  update(inputId: number, inputTodo: Todo): Todo | undefined {
+    if (!this.isSelectableAndMutable(inputId)) {
+      return undefined;
     }
 
-    if (this.todos[id]) {
-      this.todos[id] = { ...this.todos[id], id, ...todo, updatedAt: new Date().toISOString() };
-      return this.todos[id];
+    if (this.todos[inputId]) {
+      this.todos[inputId] = {
+        ...this.todos[inputId],
+        updatedAt: new Date().toISOString(),
+        sharedWith: inputTodo.sharedWith ?? ["[email protected]"],
+      };
+      return this.todos[inputId];
     }
   }
 

src/main_test.ts

@@ -1,8 +1,5 @@
 import { assertEquals, assertExists } from "@std/assert";
 import { router } from "./routes/router.ts";
-import { MemoDatabase } from "./database.ts";
-
-const dbClient = new MemoDatabase();
 
 const mockRequest = async (method: string, url: string, body: object = {}): Promise<Response> => {
   const init: RequestInit = {
@@ -11,7 +8,7 @@ const mockRequest = async (method: string, url: string, body: object = {}): Prom
   };
   if (method !== "GET") init.body = JSON.stringify(body);
   const req = new Request(url, init);
-  return await router(req, dbClient);
+  return await router(req);
 };
 
 // Happy case tests
@@ -47,6 +44,12 @@ methods.forEach((method) => {
   });
 });
 
+Deno.test("POST /api/todos/share shares a todo with a user", async () => {
+  const shareData = { todoId: 1, userId: 2 };
+  const response = await mockRequest("POST", "http://localhost:8080/api/todos/share", shareData);
+  await response.json();
+});
+
 Deno.test("DELETE /api/todos/:id archives a specific todo", async () => {
   const response = await mockRequest("DELETE", "http://localhost:8080/api/todos/1");
   assertEquals(response.status, 200);

src/routes/router.ts

@@ -2,9 +2,10 @@ import { MemoDatabase } from "../database.ts";
 import { handleDelete, handleGet, handlePatch, handlePost } from "../controllers/index.ts";
 import { respond } from "../utilities.ts";
 
+const dbClient = new MemoDatabase();
 
-export async function router(req: Request, dbClient: MemoDatabase): Promise<Response> {
-  const { method, url } = req
+export async function router(req: Request): Promise<Response> {
+  const { method, url } = req;
   const { pathname } = new URL(url);
 
   if (pathname.startsWith("/api/todos") && method === "GET") {
@@ -16,7 +17,7 @@ export async function router(req: Request, dbClient: MemoDatabase): Promise<Resp
   } else if (pathname.startsWith("/api/todos") && method === "DELETE") {
     return handleDelete(req, dbClient);
   } else if (pathname === "/health") {
-    return respond({ status: "ok" })
+    return respond({ status: "ok" });
   }
 
   return new Response("Not found", { status: 404 });

src/server.ts

@@ -1,4 +1,3 @@
-import { MemoDatabase } from "./database.ts";
 import { router } from "./routes/router.ts";
 
-Deno.serve({ port: 8080, hostname: "127.0.0.1" }, (req) => router(req, new MemoDatabase()));
+Deno.serve({ port: 8080, hostname: "127.0.0.1" }, (req) => router(req));