Getting Started With Deno 2.0 & MongoDB

1
const PORT = 3000;
2
3
async function handler(req: Request): Promise<Response> {
4
  const url = new URL(req.url);
5
  const path = url.pathname;
6
7
  if (req.method === "GET" && path === "/") {
8
    return new Response("Hello, World!");
9
  } else if (req.method === "POST" && path === "/api/todos") {
10
    // Handle POST /api/todos
11
  } else if (req.method === "GET" && path === "/api/todos") {
12
    // Handle GET /api/todos
13
  } else if (req.method === "GET" && path === "/api/todos/incomplete/count") {
14
    // Handle GET /api/todos/incomplete/count
15
  } else if (req.method === "GET" && path.startsWith("/api/todos/")) {
16
    // Handle GET /api/todos/:id
17
  } else if (req.method === "PUT" && path.startsWith("/api/todos/")) {
18
    // Handle PUT /api/todos/:id
19
  } else if (req.method === "DELETE" && path.startsWith("/api/todos/")) {
20
    // Handle DELETE /api/todos/:id
21
  } else {
22
    return new Response("Not Found", { status: 404 });
23
  }
24
}
25
26
console.log(`HTTP webserver running. Access it at: http://localhost:${PORT}/`);
27
Deno.serve({ port: PORT }, handler);

1
deno run --allow-env --allow-read --allow-net --allow-sys --env --watch server.ts

1
deno -ERNS --env --watch server.ts

1
import { MongoClient } from "npm:[email protected]";
2
3
const MONGODB_URI = Deno.env.get("MONGODB_URI") || "";
4
const DB_NAME = Deno.env.get("DB_NAME") || "todo_db";
5
6
if (!MONGODB_URI) {
7
  console.error("MONGODB_URI is not set");
8
  Deno.exit(1);
9
}
10
11
const client = new MongoClient(MONGODB_URI);
12
13
try {
14
  await client.connect();
15
  await client.db("admin").command({ ping: 1 });
16
  console.log("Connected to MongoDB");
17
} catch (error) {
18
  console.error("Error connecting to MongoDB:", error);
19
  Deno.exit(1);
20
}
21
22
const db = client.db(DB_NAME);
23
const todos = db.collection("todos");
24
25
export { db, todos };

1
MONGODB_URI="...your connection string..."
2
DB_NAME="todo_db"

1
import { todos } from "../db.ts";
2
import { ObjectId } from "npm:[email protected]";

1
// ... imports
2
3
async function addTodo(req: Request): Promise<Response> {
4
  try {
5
    const body = await req.json();
6
    const result = await todos.insertOne(body);
7
    return new Response(JSON.stringify({ id: result.insertedId }), {
8
      status: 201,
9
      headers: { "Content-Type": "application/json" },
10
    });
11
  } catch (error) {
12
    return new Response(JSON.stringify({ error: error.message }), {
13
      status: 400,
14
      headers: { "Content-Type": "application/json" },
15
    });
16
  }
17
}
18
19
export { addTodo };

1
import { addTodo } from "./controllers/todoController.ts";
2
// ... existing code
3
4
async function handler(req: Request): Promise<Response> {
5
  // ... existing code
6
  else if (req.method === "POST" && path === "/api/todos") {
7
    return await addTodo(req);
8
  }
9
  // ... existing code
10
}

1
curl -X POST http://localhost:3000/api/todos -H "Content-Type: application/json" -d '{"title": "Todo 1", "complete": false}'

1
// ... existing code
2
3
async function getTodos(): Promise<Response> {
4
  try {
5
    const allTodos = await todos.find().toArray();
6
    return new Response(JSON.stringify(allTodos), {
7
      headers: { "Content-Type": "application/json" },
8
    });
9
  } catch (error) {
10
    return new Response(JSON.stringify({ error: error.message }), {
11
      status: 500,
12
      headers: { "Content-Type": "application/json" },
13
    });
14
  }
15
}
16
17
export { addTodo, getTodos };

1
import { addTodo, getTodos } from "./controllers/todoController.ts";
2
// ... existing code
3
4
async function handler(req: Request): Promise<Response> {
5
  // ... existing code
6
  else if (req.method === "GET" && path === "/api/todos") {
7
    return await getTodos();
8
  }
9
  // ... existing code
10
}

1
curl http://localhost:3000/api/todos

1
// ... existing code
2
3
async function getTodo(id: string): Promise<Response> {
4
  try {
5
    const todo = await todos.findOne({ _id: new ObjectId(id) });
6
    if (!todo) {
7
      return new Response(JSON.stringify({ error: "Todo not found" }), {
8
        status: 404,
9
        headers: { "Content-Type": "application/json" },
10
      });
11
    }
12
    return new Response(JSON.stringify(todo), {
13
      headers: { "Content-Type": "application/json" },
14
    });
15
  } catch (error) {
16
    return new Response(JSON.stringify({ error: error.message }), {
17
      status: 500,
18
      headers: { "Content-Type": "application/json" },
19
    });
20
  }
21
}
22
23
export { addTodo, getTodos, getTodo };

1
import { addTodo, getTodos, getTodo } from "./controllers/todoController.ts";
2
// ... existing code
3
4
async function handler(req: Request): Promise<Response> {
5
  // ... existing code
6
  else if (req.method === "GET" && path.startsWith("/api/todos/")) {
7
    const id = path.split("/")[3];
8
    return await getTodo(id);
9
  }
10
  // ... existing code
11
}

1
curl http://localhost:3000/api/todos/<...id here...>
2
# example: 
3
# curl http://localhost:3000/api/todos/67005eef3bf67a631efc95f6

1
// ... existing code
2
3
async function updateTodo(id: string, req: Request): Promise<Response> {
4
  try {
5
    const body = await req.json();
6
    const result = await todos.updateOne(
7
      { _id: new ObjectId(id) },
8
      { $set: body },
9
    );
10
    if (result.matchedCount === 0) {
11
      return new Response(JSON.stringify({ error: "Todo not found" }), {
12
        status: 404,
13
        headers: { "Content-Type": "application/json" },
14
      });
15
    }
16
    return new Response(JSON.stringify({ updated: result.modifiedCount }), {
17
      headers: { "Content-Type": "application/json" },
18
    });
19
  } catch (error) {
20
    return new Response(JSON.stringify({ error: error.message }), {
21
      status: 400,
22
      headers: { "Content-Type": "application/json" },
23
    });
24
  }
25
}
26
27
export { addTodo, getTodos, getTodo, updateTodo };

1
import { addTodo, getTodos, getTodo, updateTodo } from "./controllers/todoController.ts";
2
// ... existing code
3
4
async function handler(req: Request): Promise<Response> {
5
  // ... existing code
6
  else if (req.method === "PUT" && path.startsWith("/api/todos/")) {
7
    const id = path.split("/")[3];
8
    return await updateTodo(id, req);
9
  }
10
  // ... existing code
11
}

1
curl -X PUT http://localhost:3000/api/todos/<...id here...> -H "Content-Type: application/json" -d '{"title": "Updated Todo", "complete": true}'

1
// ... existing code
2
3
async function deleteTodo(id: string): Promise<Response> {
4
  try {
5
    const result = await todos.deleteOne({ _id: new ObjectId(id) });
6
    if (result.deletedCount === 0) {
7
      return new Response(JSON.stringify({ error: "Todo not found" }), {
8
        status: 404,
9
        headers: { "Content-Type": "application/json" },
10
      });
11
    }
12
    return new Response(JSON.stringify({ deleted: result.deletedCount }), {
13
      status: 200,
14
      headers: { "Content-Type": "application/json" },
15
    });
16
  } catch (error) {
17
    return new Response(JSON.stringify({ error: error.message }), {
18
      status: 400,
19
      headers: { "Content-Type": "application/json" },
20
    });
21
  }
22
}
23
24
export { addTodo, getTodos, getTodo, updateTodo, deleteTodo };

1
import { addTodo, getTodos, getTodo, updateTodo, deleteTodo } from "./controllers/todoController.ts";
2
// ... existing code
3
4
async function handler(req: Request): Promise<Response> {
5
  // ... existing code
6
  else if (req.method === "DELETE" && path.startsWith("/api/todos/")) {
7
    const id = path.split("/")[3];
8
    return await deleteTodo(id);
9
  }
10
  // ... existing code
11
}

1
curl -X DELETE http://localhost:3000/api/todos/<...id here...>

1
// ... existing code
2
3
async function getIncompleteTodos(): Promise<Response> {
4
  try {
5
    const pipeline = [
6
      { $match: { complete: false } },
7
      { $count: "incomplete" },
8
    ];
9
    const result = await todos.aggregate(pipeline).toArray();
10
    const incompleteCount = result[0]?.incomplete || 0;
11
    return new Response(JSON.stringify({ incompleteCount }), {
12
      headers: { "Content-Type": "application/json" },
13
    });
14
  } catch (error) {
15
    return new Response(JSON.stringify({ error: error.message }), {
16
      status: 500,
17
      headers: { "Content-Type": "application/json" },
18
    });
19
  }
20
}
21
22
export { addTodo, deleteTodo, getIncompleteTodos, getTodo, getTodos, updateTodo };

1
import { addTodo, deleteTodo, getTodo, getTodos, updateTodo, getIncompleteTodos } from "./controllers/todoController.ts";
2
// ... existing code
3
4
async function handler(req: Request): Promise<Response> {
5
  // ... existing code
6
  else if (req.method === "GET" && path === "/api/todos/incomplete/count") {
7
    return await getIncompleteTodos();
8
  }
9
  // ... existing code
10
}

1
curl http://localhost:3000/api/todos/incomplete/count