Ora il db funge più veramente e si possono inviare i problemi

server/db/database.js

@@ -1,15 +1,72 @@
+import crypto from 'crypto'
+
 import { readFile, writeFile, access, constants } from 'fs/promises'
 
-export function createDatabase(path, initialValue) {
-    return { path, initialValue }
+function once(fn, message) {
+    let flag = false
+
+    return (...args) => {
+        if (flag) {
+            throw new Error(message ?? `cannot run more than once`)
+        }
+        flag = true
+        return fn(...args)
+    }
 }
 
-async function withDatabase({ path, initialValue }, fn) {
+function createMutex() {
+    let locked = false
+    const waiters = []
+
+    const unlock = () => {
+        if (waiters.length > 0) {
+            console.log(`[Mutex] Passing lock to next in queue (of size ${waiters.length})`)
+            const resolve = waiters.shift()
+            resolve(once(unlock, `lock already released`))
+        } else {
+            locked = false
+            console.log(`[Mutex] Releasing the lock`)
+        }
+    }
+
+    const lock = () => {
+        if (locked) {
+            console.log(`[Mutex] Putting into queue`)
+            return new Promise(resolve => {
+                waiters.push(resolve)
+            })
+        } else {
+            console.log(`[Mutex] Acquiring the lock`)
+            locked = true
+            return once(unlock, `lock already released`)
+        }
+    }
+
+    return { lock }
+}
+
+// l = createLock()
+// unlock1 = await l.lock() // immediate
+//                                          unlock2 = await l.lock() // hangs...
+// unlock1()                                // l2 restarts...
+//                                          unlock2() // no waiters so noop
+
+export function createDatabase(path, initialValue) {
+    return {
+        path,
+        initialValue,
+        mu: createMutex(),
+    }
+}
+
+async function withDatabase({ path, initialValue, mu }, fn) {
+    const unlock = await mu.lock()
+
     try {
         await access(path, constants.R_OK)
     } catch (e) {
         console.log(`[Database] Creating empty database into "${path}"`)
-        await writeFile(path, JSON.stringify(initialValue, null, 2))
+        await writeFile(path, JSON.stringify(initialValue, null, 4))
     }
 
     console.log(`[Database] Loading database from "${path}"`)
@@ -18,40 +75,83 @@ async function withDatabase({ path, initialValue }, fn) {
     const result = await fn(state)
 
     console.log(`[Database] Saving database to "${path}"`)
-    await writeFile(path, JSON.stringify(state, null, 2))
+    await writeFile(path, JSON.stringify(state, null, 4))
+
+    unlock()
 
     return result
 }
 
-function createTable(tableName) {
-    return {
-        create() {},
-        get() {},
-        update() {},
-        delete() {},
-    }
-}
-
-export const User = createTable('users')
-export const Problem = createTable('problems')
+export const getUsers = db =>
+    withDatabase(db, state => {
+        return Object.values(state.users)
+    })
 
 export const getUser = (db, id) =>
     withDatabase(db, state => {
-        return state.users[id]
+        return state.users[id] ?? null
     })
 
-export const createUser = (db, { email, username, password }) =>
+// export const createUser = (db, { email, username }) =>
+//     withDatabase(db, state => {
+//         state.users[username] = {
+//             email,
+//             username,
+//         }
+//     })
+
+// export const updateUser = (db, username, { email, password }) =>
+//     withDatabase(db, state => {
+//         state.users[username] = {
+//             email,
+//             password,
+//         }
+//     })
+
+//
+// Problems
+//
+
+export const getProblem = (db, id) =>
     withDatabase(db, state => {
-        state.users[email] = {
-            username,
-            password,
+        return state.problems[id]
+    })
+
+export const getProblems = db =>
+    withDatabase(db, state => {
+        return Object.values(state.problems)
+    })
+
+//
+// Solutions
+//
+
+export const createSolution = (db, { userId, problemId, content }) =>
+    withDatabase(db, state => {
+        const id = crypto.randomBytes(10).toString('hex')
+        state.solutions[id] = {
+            id,
+            userId,
+            problemId,
+            content,
         }
     })
 
-export const updateUser = (db, username, { email, password }) =>
+export const getSolution = (db, id) =>
     withDatabase(db, state => {
-        state.users[username] = {
-            email,
-            password,
-        }
+        return state.solutions[id]
+    })
+
+export const getSolutions = (db, { userId, problemId } = {}) =>
+    withDatabase(db, state => {
+        let solutions = Object.values(state.solutions)
+
+        if (userId) {
+            solutions = solutions.filter(s => s.userId === userId)
+        }
+        if (problemId) {
+            solutions = solutions.filter(s => s.problemId === problemId)
+        }
+
+        return solutions
     })

server/middlewares.js

@@ -1,18 +1,17 @@
 import { Router } from 'express'
 
-import chalk from 'chalk'
-import { toLocalISO } from '../utils/util.js'
-
-export class StatusRouter extends Router {
-    constructor() {
-        super()
-
-        this.get('/', (req, res) => {
-            res.json({ status: 'ok' })
-        })
-    }
+const createRouter = setup => options => {
+    const r = new Router()
+    setup(r, options)
+    return r
 }
 
+export const createStatusRouter = createRouter(r => {
+    r.get('/', (req, res) => {
+        res.json({ url: req.originalUrl, status: 'ok' })
+    })
+})
+
 export class PingRouter extends Router {
     constructor() {
         super()
@@ -28,10 +27,16 @@ export class PingRouter extends Router {
     }
 }
 
+export const INVALID_SESSION = `invalid session token`
+
 export const authMiddleware = getUserForSession => async (req, res, next) => {
     if (req.cookies.sid) {
-        req.user = await getUserForSession(req.cookies.sid)
-        console.log('Request from user: ' + req.user)
+        const user = await getUserForSession(req.cookies.sid)
+        if (user) {
+            req.user = user
+        } else {
+            res.cookie('sid', '', { expires: new Date() })
+        }
     }
 
     next()

server/routes.js

@@ -5,8 +5,16 @@ import cookieParser from 'cookie-parser'
 
 import express from 'express'
 
-import { authMiddleware, PingRouter, StatusRouter } from './middlewares.js'
-import { createDatabase, getUser, updateUser } from './db/database.js'
+import { createStatusRouter, PingRouter } from './middlewares.js'
+import {
+    createDatabase,
+    createSolution,
+    getProblem,
+    getProblems,
+    getSolutions,
+    getUser,
+    getUsers,
+} from './db/database.js'
 import { initialDatabaseValue } from './db/example-data.js'
 
 export async function createApiRouter() {
@@ -24,35 +32,38 @@ export async function createApiRouter() {
 
     const db = createDatabase('./db.local.json', initialDatabaseValue)
 
+    async function getRequestUser(req) {
+        const userId = sessions.getUserForSession(req.cookies.sid)
+        if (!userId) {
+            return null
+        }
+
+        const user = await getUser(db, userId)
+
+        return user
+    }
+
     const r = express.Router()
 
     r.use(bodyParser.json())
     r.use(cookieParser())
 
-    r.use(authMiddleware(sid => sessions.getUserForSession(sid)))
-
-    r.use('/api/status', new StatusRouter())
+    r.use('/api/status', createStatusRouter())
     r.use('/api/ping', new PingRouter())
 
     r.get('/api/current-user', async (req, res) => {
-        const userId = sessions.getUserForSession(req.cookies.sid)
-        if (!userId) {
-            res.cookie('sid', '', { expires: new Date() })
-            res.status(400)
-            res.end('Invalid session token')
+        res.json(await getRequestUser(req))
+    })
+
+    r.post('/api/login', async (req, res) => {
+        const { username } = req.body
+
+        const user = await getUser(db, username)
+        if (!user) {
+            res.sendStatus(403)
             return
         }
 
-        const user = await getUser(db, userId)
-
-        res.json({
-            username: userId,
-            ...user,
-        })
-    })
-
-    r.post('/api/login', (req, res) => {
-        const { username } = req.body
         res.cookie('sid', sessions.createSession(username), { maxAge: 1000 * 60 * 60 * 24 * 7 })
         res.json({ status: 'ok' })
     })
@@ -62,20 +73,83 @@ export async function createApiRouter() {
         res.json({ status: 'ok' })
     })
 
-    r.get('/api/user/:id', async (req, res) => {
-        const user = await getUser(db, req.params.id)
-
-        if (user) {
-            res.json(user)
-        } else {
-            res.sendStatus(404)
+    r.get('/api/users', async (req, res) => {
+        const requestUser = await getRequestUser(req)
+        if (requestUser.role !== 'admin' && requestUser.role !== 'moderator') {
+            res.sendStatus(401)
+            return
         }
+
+        const users = await getUsers(db)
+        res.json(users)
     })
 
-    r.post('/api/user/:id', async (req, res) => {
-        await updateUser(db, req.params.id, req.body)
-        res.sendStatus(200)
+    r.get('/api/problems', async (req, res) => {
+        res.json(await getProblems(db))
     })
 
+    r.get('/api/problem/:id', async (req, res) => {
+        res.json(await getProblem(db, req.params.id))
+    })
+
+    r.get('/api/solutions', async (req, res) => {
+        let queryUserId = req.query.user
+        let queryProblemId = req.query.problem
+
+        const requestUser = await getRequestUser(req)
+        if (!requestUser) {
+            res.sendStatus(401)
+            return
+        }
+
+        // if current user is not an administrator then force the user query to current user
+        if (requestUser.role !== 'admin' && requestUser.role !== 'moderator') {
+            queryUserId = requestUser.username
+        }
+
+        res.json(await getSolutions(db, { userId: queryUserId, problemId: queryProblemId }))
+    })
+
+    r.post('/api/solution', async (req, res) => {
+        const user = await getRequestUser(req)
+        if (!user) {
+            res.sendStatus(401)
+            return
+        }
+
+        await createSolution(db, {
+            userId: user.username,
+            problemId: req.body.problemId,
+            content: req.body.content,
+        })
+
+        res.send({ status: 'ok' })
+    })
+
+    r.get('/api/user/:id', async (req, res) => {
+        const requestUser = await getRequestUser(req)
+        if (!requestUser) {
+            res.sendStatus(401)
+            return
+        }
+        if (requestUser.role !== 'admin' && requestUser.role !== 'moderator') {
+            res.sendStatus(401)
+            return
+        }
+
+        const requestedUser = await getUser(db, req.params.id)
+        if (!requestedUser) {
+            res.sendStatus(404)
+            return
+        }
+
+        res.json(requestedUser)
+    })
+
+    // r.post('/api/user/:id', async (req, res) => {
+    //     await updateUser(db, req.params.id, req.body)
+    //     res.sendStatus(200)
+    // })
+
     return r
 }