Spaces:
Sleeping
Sleeping
Download src/server/route.js from dangkhoa2016/Nodejs-JSON-API-Server: direct link, hf CLI and curl.
- Browser
- Download file 15.7 kB
-
https://huggingface.co/spaces/dangkhoa2016/Nodejs-JSON-API-Server/resolve/main/src/server/route.js
- Command line
-
hf download hf://spaces/dangkhoa2016/Nodejs-JSON-API-Server/src/server/route.js
-
curl -L -o route.js https://huggingface.co/spaces/dangkhoa2016/Nodejs-JSON-API-Server/resolve/main/src/server/route.js
15.7 kB
| ; | |
| const { port, maxBodySize, adminKey, sensitiveKeys, rateLimitEnabled, rateLimitMax, rateLimitWindowMs, rateLimitWindowSec } = require('../config'); | |
| const argon2 = require('argon2'); | |
| const db = require('../db'); | |
| const { seed } = require('../db/seed'); | |
| const { SETTING_DEFS } = require('../db/seed-settings'); | |
| const { runtimeConfig } = require('../config/runtime-config'); | |
| module.exports = function createRouter(rateLimiter, faviconIco, faviconPng, redis) { | |
| function json(res, status, data) { | |
| const body = JSON.stringify(data); | |
| res.writeHead(status, { | |
| 'Content-Type': 'application/json; charset=utf-8', | |
| 'Access-Control-Allow-Origin': '*', | |
| 'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS', | |
| 'Access-Control-Allow-Headers': 'Content-Type, Authorization', | |
| 'X-Powered-By': 'json-api-server/1.0', | |
| }); | |
| res.end(body); | |
| } | |
| function notFound(res, msg = 'Not Found') { | |
| json(res, 404, { error: msg }); | |
| } | |
| function badRequest(res, msg = 'Bad Request') { | |
| json(res, 400, { error: msg }); | |
| } | |
| const BODY_TOO_LARGE = Symbol('BODY_TOO_LARGE'); | |
| function readBody(req, res) { | |
| return new Promise((resolve, reject) => { | |
| let body = ''; | |
| req.on('data', (chunk) => { | |
| body += chunk; | |
| if (body.length > maxBodySize) { | |
| json(res, 413, { error: 'Request body too large', message: `Body exceeds ${maxBodySize} bytes limit` }); | |
| req.destroy(); | |
| reject(BODY_TOO_LARGE); | |
| } | |
| }); | |
| req.on('end', () => { | |
| try { | |
| let parsed = body ? JSON.parse(body) : {}; | |
| if (parsed === null) parsed = {}; | |
| resolve(parsed); | |
| } catch (_) { | |
| reject(new Error('Invalid JSON')); | |
| } | |
| }); | |
| req.on('error', reject); | |
| }); | |
| } | |
| async function readBodySafe(req, res) { | |
| try { | |
| return await readBody(req, res); | |
| } catch (e) { | |
| if (e !== BODY_TOO_LARGE) badRequest(res, 'Invalid JSON body'); | |
| } | |
| return null; | |
| } | |
| function parseRoute(pathname) { | |
| const parts = pathname.replace(/^\/+|\/+$/g, '').split('/'); | |
| if (parts[0] !== 'api') return null; | |
| parts.shift(); | |
| const [table, rawId, sub] = parts; | |
| const id = rawId ? parseInt(rawId, 10) : null; | |
| if (!db.TABLES.includes(table)) return null; | |
| if (rawId && isNaN(id)) return { invalidId: true }; | |
| return { table, id, sub }; | |
| } | |
| const NESTED = { | |
| users: { posts: 'userId', albums: 'userId', todos: 'userId' }, | |
| posts: { comments: 'postId' }, | |
| albums: { photos: 'albumId' }, | |
| }; | |
| async function handleGET(req, res, route, query) { | |
| const { table, id, sub } = route; | |
| for (const param of ['_page', '_limit', '_start', '_end']) { | |
| if (query[param] !== undefined) { | |
| if (query[param] === '') { | |
| delete query[param]; | |
| } else { | |
| const val = Number(query[param]); | |
| if (!Number.isInteger(val) || val < 0) { | |
| return badRequest(res, `Invalid ${param}: must be a non-negative integer`); | |
| } | |
| if ((param === '_page' || param === '_limit') && val < 1) { | |
| return badRequest(res, `Invalid ${param}: must be a positive integer`); | |
| } | |
| } | |
| } | |
| } | |
| if (id !== null && sub) { | |
| const parentExists = db.getOne(table, id); | |
| if (!parentExists) return notFound(res); | |
| const fkMap = NESTED[table] || {}; | |
| if (!fkMap[sub]) return notFound(res, `No nested route '${sub}' under '${table}'`); | |
| const results = db.listAll(sub, { [fkMap[sub]]: String(id), ...query }); | |
| return json(res, 200, results); | |
| } | |
| if (id !== null) { | |
| const row = db.getOne(table, id); | |
| return row ? json(res, 200, row) : notFound(res); | |
| } | |
| const rows = db.listAll(table, query); | |
| json(res, 200, rows); | |
| } | |
| async function handlePOST(req, res, route) { | |
| const { table } = route; | |
| const body = await readBodySafe(req, res); | |
| if (body === null) return; | |
| if (!body.id) body.id = db.nextId(table); | |
| try { | |
| const created = db.insertOne(table, body); | |
| json(res, 201, created); | |
| } catch (e) { | |
| badRequest(res, e.message); | |
| } | |
| } | |
| async function handlePUT(req, res, route) { | |
| const { table, id } = route; | |
| if (id === null) return badRequest(res, 'PUT requires an id'); | |
| const body = await readBodySafe(req, res); | |
| if (body === null) return; | |
| const updated = db.updateOne(table, id, body, true); | |
| updated ? json(res, 200, updated) : notFound(res); | |
| } | |
| async function handlePATCH(req, res, route) { | |
| const { table, id } = route; | |
| if (id === null) return badRequest(res, 'PATCH requires an id'); | |
| const body = await readBodySafe(req, res); | |
| if (body === null) return; | |
| const updated = db.updateOne(table, id, body, false); | |
| updated ? json(res, 200, updated) : notFound(res); | |
| } | |
| function handleDELETE(_req, res, route) { | |
| const { table, id } = route; | |
| if (id === null) return badRequest(res, 'DELETE requires an id'); | |
| const deleted = db.deleteOne(table, id); | |
| deleted ? json(res, 200, {}) : notFound(res); | |
| } | |
| function handleHealth(res) { | |
| json(res, 200, { | |
| status: 'ok', | |
| redis: redis.connected ? 'connected' : 'disconnected', | |
| tables: db.TABLES, | |
| rateLimit: { | |
| enabled: runtimeConfig.get('rateLimitEnabled'), | |
| max: runtimeConfig.get('rateLimitMax'), | |
| windowMs: runtimeConfig.get('rateLimitWindowMs'), | |
| }, | |
| }); | |
| } | |
| const authCache = new Map(); | |
| const AUTH_CACHE_TTL_MS = 5_000; | |
| function getCachedAuth(token) { | |
| const entry = authCache.get(token); | |
| if (entry && Date.now() - entry.ts < AUTH_CACHE_TTL_MS) { | |
| return entry.valid; | |
| } | |
| authCache.delete(token); | |
| return undefined; | |
| } | |
| function setCachedAuth(token, valid) { | |
| if (authCache.size > 1000) { | |
| const cutoff = Date.now() - AUTH_CACHE_TTL_MS; | |
| for (const [key, entry] of authCache) { | |
| if (entry.ts < cutoff) authCache.delete(key); | |
| } | |
| } | |
| authCache.set(token, { valid, ts: Date.now() }); | |
| } | |
| function resetAuthCache() { | |
| authCache.clear(); | |
| } | |
| async function checkAdminAuth(req) { | |
| if (!adminKey) return false; | |
| const auth = req.headers['authorization'] || ''; | |
| const match = auth.match(/^Bearer\s+(.+)$/i); | |
| if (!match) return false; | |
| const token = match[1]; | |
| const cached = getCachedAuth(token); | |
| if (cached !== undefined) return cached; | |
| try { | |
| const d = db.getWrappedDb(); | |
| const row = d.prepare('SELECT value FROM settings WHERE key = ?').get('ADMIN_KEY'); | |
| if (!row) return false; | |
| const valid = await argon2.verify(row.value, token); | |
| setCachedAuth(token, valid); | |
| return valid; | |
| } catch { | |
| setCachedAuth(token, false); | |
| return false; | |
| } | |
| } | |
| async function handleAdmin(req, res, pathname, method) { | |
| if (!(await checkAdminAuth(req))) { | |
| return json(res, 401, { error: 'Unauthorized' }); | |
| } | |
| if (pathname === '/api/admin/settings' && method === 'GET') { | |
| const rows = db.listAll('settings').map((r) => sensitiveKeys.includes(r.key) ? { ...r, value: '***' } : r); | |
| return json(res, 200, rows); | |
| } | |
| const settingsMatch = pathname.match(/^\/api\/admin\/settings\/(.+)$/); | |
| if (settingsMatch && method === 'PATCH') { | |
| return await handleAdminPatchSetting(req, res, settingsMatch[1]); | |
| } | |
| if (pathname === '/api/admin/reset-database' && method === 'POST') { | |
| return await handleAdminResetDatabase(req, res); | |
| } | |
| return notFound(res, `Unknown admin route: ${pathname}`); | |
| } | |
| const RATE_LIMIT_SETTINGS = new Set([ | |
| 'RATE_LIMIT_ENABLED', | |
| 'RATE_LIMIT_MAX', | |
| 'RATE_LIMIT_WINDOW_MS', | |
| ]); | |
| const REDIS_SETTINGS = new Set([ | |
| 'REDIS_HOST', | |
| 'REDIS_PORT', | |
| 'REDIS_DB', | |
| 'REDIS_PASSWORD', | |
| 'REDIS_URL', | |
| ]); | |
| function applyRateLimitUpdate(settingKey, value) { | |
| const updates = {}; | |
| switch (settingKey) { | |
| case 'RATE_LIMIT_ENABLED': { | |
| const enabled = value !== 'false' && value !== false; | |
| updates.enabled = enabled; | |
| runtimeConfig.set('rateLimitEnabled', enabled); | |
| break; | |
| } | |
| case 'RATE_LIMIT_MAX': { | |
| const max = parseInt(value, 10); | |
| if (!isNaN(max)) { | |
| updates.max = max; | |
| runtimeConfig.set('rateLimitMax', max); | |
| } | |
| break; | |
| } | |
| case 'RATE_LIMIT_WINDOW_MS': { | |
| const windowMs = parseInt(value, 10); | |
| if (!isNaN(windowMs)) { | |
| updates.windowMs = windowMs; | |
| runtimeConfig.set('rateLimitWindowMs', windowMs); | |
| runtimeConfig.set('rateLimitWindowSec', Math.ceil(windowMs / 1000)); | |
| } | |
| break; | |
| } | |
| } | |
| if (Object.keys(updates).length > 0) { | |
| rateLimiter.updateConfig(updates); | |
| } | |
| } | |
| async function applyRedisUpdate() { | |
| const d = db.getWrappedDb(); | |
| const rows = d.prepare( | |
| 'SELECT key, value FROM settings WHERE key IN (?, ?, ?, ?, ?)' | |
| ).all('REDIS_URL', 'REDIS_HOST', 'REDIS_PORT', 'REDIS_DB', 'REDIS_PASSWORD'); | |
| const settings = {}; | |
| for (const row of rows) { | |
| settings[row.key] = row.value; | |
| } | |
| const opts = settings.REDIS_URL | |
| ? { url: settings.REDIS_URL } | |
| : { | |
| host: settings.REDIS_HOST || '127.0.0.1', | |
| port: parseInt(settings.REDIS_PORT || '6379', 10), | |
| db: parseInt(settings.REDIS_DB || '0', 10), | |
| password: settings.REDIS_PASSWORD || undefined, | |
| }; | |
| await redis.reconnect(opts); | |
| } | |
| async function applyRuntimeUpdate(settingKey, value) { | |
| if (RATE_LIMIT_SETTINGS.has(settingKey)) { | |
| applyRateLimitUpdate(settingKey, value); | |
| } else if (REDIS_SETTINGS.has(settingKey)) { | |
| await applyRedisUpdate(); | |
| } | |
| } | |
| async function handleAdminPatchSetting(req, res, settingKey) { | |
| const body = await readBodySafe(req, res); | |
| if (body === null) return; | |
| if (body.value === undefined) { | |
| return badRequest(res, 'Missing "value" in request body'); | |
| } | |
| if (body.value === null || typeof body.value === 'object') { | |
| return badRequest(res, 'Setting value must be a string or number'); | |
| } | |
| const d = db.getWrappedDb(); | |
| const existing = d.prepare('SELECT * FROM settings WHERE key = ?').get(settingKey); | |
| /* v8 ignore next */ if (!existing) { | |
| const def = SETTING_DEFS.find(s => s.key === settingKey); | |
| /* v8 ignore next */ if (!def) return notFound(res, `Setting '${settingKey}' not found`); | |
| const valToStore = settingKey === 'ADMIN_KEY' ? await argon2.hash(body.value) : body.value; | |
| d.prepare(`INSERT INTO settings (key, value, description, updated_at) VALUES (?, ?, ?, datetime('now'))`).run(settingKey, valToStore, def.description); | |
| const created = d.prepare('SELECT * FROM settings WHERE key = ?').get(settingKey); | |
| applyRuntimeUpdate(settingKey, body.value).catch(err => { | |
| console.error('[Runtime] Failed to apply setting:', err.message); | |
| }); | |
| return json(res, 201, created); | |
| } | |
| const valToStore = settingKey === 'ADMIN_KEY' ? await argon2.hash(body.value) : body.value; | |
| d.prepare(`UPDATE settings SET value = ?, updated_at = datetime('now') WHERE key = ?`).run(valToStore, settingKey); | |
| const updated = d.prepare('SELECT * FROM settings WHERE key = ?').get(settingKey); | |
| applyRuntimeUpdate(settingKey, body.value).catch(err => { | |
| console.error('[Runtime] Failed to apply setting:', err.message); | |
| }); | |
| json(res, 200, updated); | |
| } | |
| let resetLock = Promise.resolve(); | |
| const RESET_LOCK_TIMEOUT_MS = 30_000; | |
| async function withResetLock(fn) { | |
| let release; | |
| let timer; | |
| const prev = resetLock; | |
| resetLock = new Promise((resolve) => { release = resolve; }); | |
| await prev; | |
| timer = setTimeout(release, RESET_LOCK_TIMEOUT_MS); | |
| try { | |
| return await fn(); | |
| } finally { | |
| clearTimeout(timer); | |
| release(); | |
| } | |
| } | |
| async function handleAdminResetDatabase(req, res) { | |
| const body = await readBodySafe(req, res); | |
| if (body === null) return; | |
| if (body.confirm !== true) { | |
| return badRequest(res, 'Reset requires confirm: true in request body'); | |
| } | |
| await withResetLock(async () => { | |
| const d = db.getWrappedDb(); | |
| d.exec('BEGIN'); | |
| try { | |
| const deleteOrder = ['photos', 'comments', 'albums', 'posts', 'todos', 'users']; | |
| for (const table of deleteOrder) { | |
| d.prepare(`DELETE FROM ${table}`).run(); | |
| } | |
| if (d.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sqlite_sequence'").get()) { | |
| d.exec('DELETE FROM sqlite_sequence'); | |
| } | |
| const fetchFn = async (url) => { | |
| const response = await globalThis.fetch(url); | |
| return response.json(); | |
| }; | |
| await seed({ database: d, fetch: fetchFn, runMigrate: false, skipTransaction: true }); | |
| d.exec('COMMIT'); | |
| json(res, 200, { message: 'Database reset and re-seeded successfully' }); | |
| } catch (error) { | |
| d.exec('ROLLBACK'); | |
| throw error; | |
| } | |
| }); | |
| } | |
| async function requestHandler(req, res) { | |
| const parsed = new URL(req.url, 'http://localhost'); | |
| const pathname = parsed.pathname.length > 1 ? parsed.pathname.replace(/\/+$/, '') : parsed.pathname; | |
| const query = Object.fromEntries(parsed.searchParams); | |
| const method = req.method.toUpperCase(); | |
| if (method === 'OPTIONS') { | |
| res.writeHead(204, { | |
| 'Access-Control-Allow-Origin': '*', | |
| 'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS', | |
| 'Access-Control-Allow-Headers': 'Content-Type, Authorization', | |
| }); | |
| return res.end(); | |
| } | |
| if (pathname === '/health' || pathname === '/api/health') { | |
| return handleHealth(res); | |
| } | |
| if (pathname === '/' || pathname === '/api') { | |
| return json(res, 200, { | |
| message: 'Nodejs JSON API Server — JSONPlaceholder-compatible REST API', | |
| version: '1.0.0', | |
| endpoints: db.TABLES.map((t) => `/api/${t}`), | |
| docs: 'GET /health for server status', | |
| }); | |
| } | |
| if (pathname === '/favicon.ico') { | |
| res.writeHead(200, { 'Content-Type': 'image/x-icon' }); | |
| return res.end(faviconIco); | |
| } | |
| if (pathname === '/favicon.png') { | |
| res.writeHead(200, { 'Content-Type': 'image/png' }); | |
| return res.end(faviconPng); | |
| } | |
| await new Promise((resolve) => { | |
| rateLimiter(req, res, resolve); | |
| }); | |
| /* v8 ignore next */ if (res.writableEnded) return; | |
| if (pathname.startsWith('/api/admin/')) { | |
| try { | |
| return await handleAdmin(req, res, pathname, method); | |
| } catch (err) { | |
| console.error('[Error]', err); | |
| return json(res, 500, { error: 'Internal Server Error', message: err.message }); | |
| } | |
| } | |
| const route = parseRoute(pathname); | |
| /* v8 ignore next */ if (!route) return notFound(res, `Unknown route: ${pathname}`); | |
| /* v8 ignore next */ if (route.invalidId) return badRequest(res, 'Invalid ID format'); | |
| try { | |
| switch (method) { | |
| case 'GET': return await handleGET(req, res, route, query); | |
| case 'POST': return await handlePOST(req, res, route); | |
| case 'PUT': return await handlePUT(req, res, route); | |
| case 'PATCH': return await handlePATCH(req, res, route); | |
| case 'DELETE': return handleDELETE(req, res, route); | |
| default: | |
| return json(res, 405, { error: `Method ${method} not allowed` }); | |
| } | |
| } catch (err) { | |
| console.error('[Error]', err); | |
| json(res, 500, { error: 'Internal Server Error', message: err.message }); | |
| } | |
| } | |
| return { requestHandler, resetAuthCache }; | |
| }; | |