Node.js Projects for Beginners to Build Portfolio

// node organise.js ./downloads
const fs = require("fs/promises");
const path = require("path");

async function organise(dir) {
  const entries = await fs.readdir(dir, { withFileTypes: true });
  for (const entry of entries) {
    if (!entry.isFile()) continue;
    const ext = path.extname(entry.name).slice(1).toLowerCase() || "other";
    const target = path.join(dir, ext);
    await fs.mkdir(target, { recursive: true });
    await fs.rename(path.join(dir, entry.name), path.join(target, entry.name));
    console.log(`moved ${entry.name} -> ${ext}/`);
  }
}

organise(process.argv[2] || ".").catch((err) => {
  console.error("Error:", err.message);
  process.exit(1);
});

// node wordcount.js notes.txt
const fs = require("fs");

const file = process.argv[2];
if (!file) {
  console.error("Usage: node wordcount.js <file>");
  process.exit(1);
}

const text = fs.readFileSync(file, "utf8");
const words = text.toLowerCase().match(/[a-z']+/g) || [];
const counts = {};
for (const w of words) counts[w] = (counts[w] || 0) + 1;

const top = Object.entries(counts).sort((a, b) => b[1] - a[1]).slice(0, 10);
console.log(`Total words: ${words.length}`);
console.table(top);

// npm init -y && npm install express
const express = require("express");
const app = express();
app.use(express.json());

let tasks = [];
let nextId = 1;

app.get("/tasks", (req, res) => res.json(tasks));

app.post("/tasks", (req, res) => {
  const { title } = req.body;
  if (!title || !title.trim()) {
    return res.status(400).json({ error: "title is required" });
  }
  const task = { id: nextId++, title: title.trim(), done: false };
  tasks.push(task);
  res.status(201).json(task);
});

app.patch("/tasks/:id", (req, res) => {
  const task = tasks.find((t) => t.id === Number(req.params.id));
  if (!task) return res.status(404).json({ error: "not found" });
  if (typeof req.body.done === "boolean") task.done = req.body.done;
  res.json(task);
});

app.delete("/tasks/:id", (req, res) => {
  const before = tasks.length;
  tasks = tasks.filter((t) => t.id !== Number(req.params.id));
  res.status(before === tasks.length ? 404 : 204).end();
});

app.listen(3000, () => console.log("API on http://localhost:3000"));

# Start the server
node server.js

# Create a task
curl -X POST http://localhost:3000/tasks \
  -H "Content-Type: application/json" \
  -d '{"title": "Write README"}'

# List tasks
curl http://localhost:3000/tasks

# Mark task 1 as done
curl -X PATCH http://localhost:3000/tasks/1 \
  -H "Content-Type: application/json" -d '{"done": true}'

# Delete task 1
curl -X DELETE -i http://localhost:3000/tasks/1

// npm install bcrypt jsonwebtoken
const bcrypt = require("bcrypt");
const jwt = require("jsonwebtoken");

const SECRET = process.env.JWT_SECRET;   // never hard-code secrets

async function hashPassword(plain) {
  return bcrypt.hash(plain, 10);
}

async function login(user, plain) {
  const ok = await bcrypt.compare(plain, user.passwordHash);
  if (!ok) return null;
  return jwt.sign({ sub: user.id }, SECRET, { expiresIn: "1h" });
}

function requireAuth(req, res, next) {
  const token = (req.headers.authorization || "").replace("Bearer ", "");
  try {
    req.user = jwt.verify(token, SECRET);
    next();
  } catch {
    res.status(401).json({ error: "unauthorised" });
  }
}

module.exports = { hashPassword, login, requireAuth };

// npm install --save-dev jest supertest
// server.js should export the app: module.exports = app;
const request = require("supertest");
const app = require("./server");

test("rejects a task without a title", async () => {
  const res = await request(app).post("/tasks").send({});
  expect(res.status).toBe(400);
});

test("creates a task", async () => {
  const res = await request(app).post("/tasks").send({ title: "Test" });
  expect(res.status).toBe(201);
  expect(res.body.title).toBe("Test");
});

// run: npx jest

# Task Manager API

A REST API for managing tasks, built with Node.js and Express.

## Features
- Create, list, update and delete tasks
- Input validation and proper status codes
- JWT authentication (protected routes)

## Run locally
```
npm install
cp .env.example .env
npm start
```

## Endpoints
| Method | Path        | Description   |
|--------|-------------|---------------|
| GET    | /tasks      | List tasks    |
| POST   | /tasks      | Create a task |

## Tests
`npm test`

## Live demo
[link]

Before publishing a Node.js project:

[ ] package.json has start and test scripts
[ ] .env.example present, .env in .gitignore
[ ] node_modules in .gitignore
[ ] Input validation on every write endpoint
[ ] Errors return JSON with a clear message
[ ] At least 5 tests
[ ] README with setup, endpoints, live link
[ ] Code formatted consistently

Project | Level | Status | Tests | Deployed | Repo link
--------|-------|--------|-------|----------|----------
        |   1   |        |       |          |
        |   2   |        |       |          |
        |   3   |        |       |          |

Goal: one finished project per level before applying.