dangkhoa2016 commited on
Commit
ad871c9
·
1 Parent(s): 5533459

refactor: extract routes into separate module with favicon support

Browse files

- Move route parsing and request dispatch into server/route.js
- Add favicon and API attribution handling
- Require /api prefix and strip trailing slashes when parsing routes
- Emit compact JSON responses to reduce payload size
- Update and extend tests for the new route handling

README.md CHANGED
@@ -280,30 +280,37 @@ json-api-server/
280
  │ │ └── rate-limiter.js # Rate limiter (Redis/in-memory, circuit breaker, escalating blocks)
281
  │ ├── redis/
282
  │ │ └── index.js # Pure-Node Redis client via RESP protocol over TCP
 
 
 
 
283
  │ └── server/
284
- │ └── index.js # HTTP server, routing, middleware, handlers
 
285
  ├── tests/
286
  │ ├── config/
287
  │ │ ├── config.test.js # Config defaults and env var branches (9)
288
  │ │ └── load-env.test.js # Load-env file loading chain and error paths (7)
289
  │ ├── db/
290
- │ │ ├── database.test.js # Database CRUD, pagination, search, sort, SQL injection (10)
291
  │ │ ├── migrate.test.js # Migration success and failure paths (2)
292
  │ │ ├── seed.test.js # Seed with real DB + mocked deps, JSONPlaceholder fetch (5)
293
  │ │ └── sql-logger.test.js # SQL query logger wrapping (5)
294
  │ ├── middleware/
295
  │ │ └── rate-limiter.test.js # In-memory, Redis, circuit breaker, proxy IPs (54)
296
  │ ├── redis/
297
- │ │ └── redis.test.js # RESP protocol encoding/parsing, constructor options (25)
298
  │ ├── server/
299
  │ │ ├── coverage-printlog.test.js # Printlog and server export V8 coverage (4)
300
  │ │ ├── graceful-shutdown.test.js # SIGINT/SIGTERM handler coverage (1)
 
301
  │ │ ├── integration.test.js # API integration tests — real HTTP + SQLite (77)
302
- │ │ └── server.test.js # Server request handler, admin auth, graceful shutdown (13)
303
  │ ├── README.md # Testing documentation
304
  │ └── helpers/
305
- │ ├── coverage.js # Test-coverage utilities (save/restore/setEnv/clearCjs)
306
  │ ├── index.js # startServer / stopServer / request utilities
 
307
  │ └── seed.js # Standalone script to create & seed temp DB
308
  │ └── seed-settings-coverage.test.js # Seed-settings.js V8 coverage (4)
309
  ├── manual/
@@ -381,7 +388,7 @@ This runs comprehensive queries to inspect row counts, column metadata, relation
381
 
382
  ## Testing
383
 
384
- Uses **vitest** with **V8 native coverage**. **218 tests across 13 test files** cover the full stack — from integration tests (real HTTP server + SQLite) to unit tests for every module.
385
 
386
  ```bash
387
  npm test # Run all tests once
@@ -402,10 +409,15 @@ See [tests/README.md](tests/README.md) for full documentation.
402
  - **SQL query logging** — `src/db/sql-logger.js` exports `wrapDb`/`wrapStmt` Proxy wrappers that log `exec`, `prepare`, `run`, `get`, and `all` calls to stderr. `src/db/index.js` uses them via `getWrappedDb()` when `DEBUG_SQL=true`.
403
  - **Multi-environment** — `src/config/index.js` requires `src/config/load-env.js` at module level, which chain-loads all dotenv files in priority order with `override: false` — existing `process.env` values and earlier files take precedence over later ones. Every consumer (server, migrate, seed) simply requires `src/config/index.js` and gets correct env values. In production, dotenv is skipped entirely — env vars must come from the deployment environment.
404
  - **SQL injection prevention** — `src/db/index.js` validates `_sort` against a whitelist of known columns and quotes identifiers with `""`; LIKE wildcards (`%`, `_`) are escaped to prevent injection through the `q` parameter
405
- - **Argon2 auth cache** — `src/server/index.js` caches `ADMIN_KEY` verification results in a `Map` with 5-second TTL, avoiding repeated argon2 hashing on burst admin requests
406
  - **CORS** enabled on all routes
407
  - **Graceful shutdown** — handles `SIGINT` and `SIGTERM` to close the server and Redis connection cleanly
408
 
409
  ## License
410
 
411
  [MIT](LICENSE) — Copyright (c) 2026 Dang Khoa <i.am@dangkhoa.dev>
 
 
 
 
 
 
280
  │ │ └── rate-limiter.js # Rate limiter (Redis/in-memory, circuit breaker, escalating blocks)
281
  │ ├── redis/
282
  │ │ └── index.js # Pure-Node Redis client via RESP protocol over TCP
283
+ │ ├── public/
284
+ │ │ ├── favicon.ico # Favicon (ICO format)
285
+ │ │ ├── favicon.png # Favicon (PNG format)
286
+ │ │ └── license.md # Flaticon license file
287
  │ └── server/
288
+ │ ├── index.js # HTTP server, graceful shutdown, startup orchestration
289
+ │ └── route.js # Route parser, request handlers, admin auth, favicon
290
  ├── tests/
291
  │ ├── config/
292
  │ │ ├── config.test.js # Config defaults and env var branches (9)
293
  │ │ └── load-env.test.js # Load-env file loading chain and error paths (7)
294
  │ ├── db/
295
+ │ │ ├── database.test.js # Database CRUD, pagination, search, sort, SQL injection, cascade delete (11)
296
  │ │ ├── migrate.test.js # Migration success and failure paths (2)
297
  │ │ ├── seed.test.js # Seed with real DB + mocked deps, JSONPlaceholder fetch (5)
298
  │ │ └── sql-logger.test.js # SQL query logger wrapping (5)
299
  │ ├── middleware/
300
  │ │ └── rate-limiter.test.js # In-memory, Redis, circuit breaker, proxy IPs (54)
301
  │ ├── redis/
302
+ │ │ └── redis.test.js # RESP protocol encoding/parsing, constructor options, eval method (27)
303
  │ ├── server/
304
  │ │ ├── coverage-printlog.test.js # Printlog and server export V8 coverage (4)
305
  │ │ ├── graceful-shutdown.test.js # SIGINT/SIGTERM handler coverage (1)
306
+ │ │ ├── index.test.js # Server request handler, admin auth, graceful shutdown (13)
307
  │ │ ├── integration.test.js # API integration tests — real HTTP + SQLite (77)
308
+ │ │ └── route.test.js # Route parsing, favicon, health, admin auth cache (14)
309
  │ ├── README.md # Testing documentation
310
  │ └── helpers/
311
+ │ ├── coverage.js # Test-coverage utilities (save/restore/setEnv/clearCjs/configMockFactory)
312
  │ ├── index.js # startServer / stopServer / request utilities
313
+ │ ├── mock-factory.js # Mock factory helpers (mkDb/mkReq/mkRes/mkRedis/mkSettingsTable)
314
  │ └── seed.js # Standalone script to create & seed temp DB
315
  │ └── seed-settings-coverage.test.js # Seed-settings.js V8 coverage (4)
316
  ├── manual/
 
388
 
389
  ## Testing
390
 
391
+ Uses **vitest** with **V8 native coverage**. **233 tests across 14 test files** cover the full stack — from integration tests (real HTTP server + SQLite) to unit tests for every module.
392
 
393
  ```bash
394
  npm test # Run all tests once
 
409
  - **SQL query logging** — `src/db/sql-logger.js` exports `wrapDb`/`wrapStmt` Proxy wrappers that log `exec`, `prepare`, `run`, `get`, and `all` calls to stderr. `src/db/index.js` uses them via `getWrappedDb()` when `DEBUG_SQL=true`.
410
  - **Multi-environment** — `src/config/index.js` requires `src/config/load-env.js` at module level, which chain-loads all dotenv files in priority order with `override: false` — existing `process.env` values and earlier files take precedence over later ones. Every consumer (server, migrate, seed) simply requires `src/config/index.js` and gets correct env values. In production, dotenv is skipped entirely — env vars must come from the deployment environment.
411
  - **SQL injection prevention** — `src/db/index.js` validates `_sort` against a whitelist of known columns and quotes identifiers with `""`; LIKE wildcards (`%`, `_`) are escaped to prevent injection through the `q` parameter
412
+ - **Argon2 auth cache** — `src/server/route.js` caches `ADMIN_KEY` verification results in a `Map` with 5-second TTL and 1,000-entry limit, avoiding repeated argon2 hashing on burst admin requests
413
  - **CORS** enabled on all routes
414
  - **Graceful shutdown** — handles `SIGINT` and `SIGTERM` to close the server and Redis connection cleanly
415
 
416
  ## License
417
 
418
  [MIT](LICENSE) — Copyright (c) 2026 Dang Khoa <i.am@dangkhoa.dev>
419
+
420
+ ## Credits
421
+
422
+ This project uses graphics from Flaticon:
423
+ * [Sustainability stickers](https://www.flaticon.com/free-stickers/sustainability) created by [Manuel Viveros - Flaticon](https://www.flaticon.com/authors/manuel-viveros?type=sticker)
src/public/favicon.ico ADDED

Git LFS Details

  • SHA256: 046d5f244e9ad7cbef5f4242f8ca7041767fce78a43acff5d90ef43f1d5f44de
  • Pointer size: 131 Bytes
  • Size of remote file: 190 kB
src/public/favicon.png ADDED

Git LFS Details

  • SHA256: d220530541cad388ffcd3c947e6a1eeec8b89d92ca78e5e629b72641fd81fa30
  • Pointer size: 130 Bytes
  • Size of remote file: 20.3 kB
src/public/license.md ADDED
@@ -0,0 +1,4 @@
 
 
 
 
 
1
+ ## Credits
2
+
3
+ This project uses graphics from Flaticon:
4
+ * [Sustainability stickers](https://www.flaticon.com/free-stickers/sustainability) created by [Manuel Viveros - Flaticon](https://www.flaticon.com/authors/manuel-viveros?type=sticker)
src/server/index.js CHANGED
@@ -1,428 +1,36 @@
1
  'use strict';
2
 
3
  const http = require('http');
 
 
4
 
5
- const { port, redisOpts, rateLimitMax, rateLimitEnabled,
6
- rateLimitWindowMs, rateLimitWindowSec, maxBodySize, adminKey, sensitiveKeys } = require('../config');
7
- const argon2 = require('argon2');
8
  const RedisClient = require('../redis');
9
  const { createRateLimiter } = require('../middleware/rate-limiter');
10
- const db = require('../db');
11
- const { seed } = require('../db/seed');
12
- const { SETTING_DEFS } = require('../db/seed-settings');
13
 
14
  const redis = new RedisClient(redisOpts);
15
 
16
  const rateLimiter = createRateLimiter(redis, { enabled: rateLimitEnabled });
17
 
 
 
 
 
 
 
 
18
  (async () => {
19
  try {
20
  await redis.connect();
21
  await redis.ping();
22
  console.log('[Redis] Connected ✓');
23
  } catch (e) {
24
- /* v8 ignore next */
25
  console.warn('[Redis] Unavailable — rate limiting falls back to in-memory:', e.message);
26
  }
27
  startServer();
28
  })();
29
 
30
- function json(res, status, data) {
31
- const body = JSON.stringify(data, null, 2);
32
- res.writeHead(status, {
33
- 'Content-Type': 'application/json; charset=utf-8',
34
- 'Access-Control-Allow-Origin': '*',
35
- 'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
36
- 'Access-Control-Allow-Headers': 'Content-Type, Authorization',
37
- 'X-Powered-By': 'json-api-server/1.0',
38
- });
39
- res.end(body);
40
- }
41
-
42
- function notFound(res, msg = 'Not Found') {
43
- json(res, 404, { error: msg });
44
- }
45
-
46
- function badRequest(res, msg = 'Bad Request') {
47
- json(res, 400, { error: msg });
48
- }
49
-
50
- const BODY_TOO_LARGE = Symbol('BODY_TOO_LARGE');
51
-
52
- function readBody(req, res) {
53
- return new Promise((resolve, reject) => {
54
- let body = '';
55
- req.on('data', (chunk) => {
56
- body += chunk;
57
- if (body.length > maxBodySize) {
58
- json(res, 413, { error: 'Request body too large', message: `Body exceeds ${maxBodySize} bytes limit` });
59
- req.destroy();
60
- reject(BODY_TOO_LARGE);
61
- }
62
- });
63
- req.on('end', () => {
64
- try {
65
- let parsed = body ? JSON.parse(body) : {};
66
- /* v8 ignore next 2 — defensive: JSON.parse can return null */
67
- if (parsed === null) parsed = {};
68
- resolve(parsed);
69
- } catch (_) {
70
- reject(new Error('Invalid JSON'));
71
- }
72
- });
73
- req.on('error', reject);
74
- });
75
- }
76
-
77
- async function readBodySafe(req, res) {
78
- try {
79
- return await readBody(req, res);
80
- } catch (e) {
81
- if (e !== BODY_TOO_LARGE) badRequest(res, 'Invalid JSON body');
82
- }
83
- return null;
84
- }
85
-
86
- function parseRoute(pathname) {
87
- const parts = pathname.replace(/^\/+|\/+$/g, '').split('/');
88
- /* v8 ignore next */
89
- if (parts[0] === 'api') parts.shift();
90
-
91
- const [table, rawId, sub] = parts;
92
- const id = rawId ? parseInt(rawId, 10) : null;
93
-
94
- if (!db.TABLES.includes(table)) return null;
95
- /* v8 ignore next */
96
- if (rawId && isNaN(id)) return { invalidId: true };
97
-
98
- return { table, id, sub };
99
- }
100
-
101
- const NESTED = {
102
- users: { posts: 'userId', albums: 'userId', todos: 'userId' },
103
- posts: { comments: 'postId' },
104
- albums: { photos: 'albumId' },
105
- };
106
-
107
- async function handleGET(req, res, route, query) {
108
- const { table, id, sub } = route;
109
-
110
- for (const param of ['_page', '_limit', '_start', '_end']) {
111
- if (query[param] !== undefined) {
112
- if (query[param] === '') {
113
- delete query[param];
114
- } else {
115
- const val = Number(query[param]);
116
- if (!Number.isInteger(val) || val < 0) {
117
- return badRequest(res, `Invalid ${param}: must be a non-negative integer`);
118
- }
119
- if ((param === '_page' || param === '_limit') && val < 1) {
120
- return badRequest(res, `Invalid ${param}: must be a positive integer`);
121
- }
122
- }
123
- }
124
- }
125
-
126
- if (id !== null && sub) {
127
- const parentExists = db.getOne(table, id);
128
- if (!parentExists) return notFound(res);
129
-
130
- /* v8 ignore next */
131
- const fkMap = NESTED[table] || {};
132
- if (!fkMap[sub]) return notFound(res, `No nested route '${sub}' under '${table}'`);
133
-
134
- const results = db.listAll(sub, { [fkMap[sub]]: String(id), ...query });
135
- return json(res, 200, results);
136
- }
137
-
138
- if (id !== null) {
139
- const row = db.getOne(table, id);
140
- return row ? json(res, 200, row) : notFound(res);
141
- }
142
-
143
- const rows = db.listAll(table, query);
144
- json(res, 200, rows);
145
- }
146
-
147
- async function handlePOST(req, res, route) {
148
- const { table } = route;
149
- const body = await readBodySafe(req, res);
150
- if (body === null) return;
151
-
152
- if (!body.id) body.id = db.nextId(table);
153
-
154
- try {
155
- const created = db.insertOne(table, body);
156
- json(res, 201, created);
157
- } catch (e) {
158
- badRequest(res, e.message);
159
- }
160
- }
161
-
162
- async function handlePUT(req, res, route) {
163
- const { table, id } = route;
164
- if (id === null) return badRequest(res, 'PUT requires an id');
165
-
166
- const body = await readBodySafe(req, res);
167
- if (body === null) return;
168
-
169
- const updated = db.updateOne(table, id, body, true);
170
- updated ? json(res, 200, updated) : notFound(res);
171
- }
172
-
173
- async function handlePATCH(req, res, route) {
174
- const { table, id } = route;
175
- if (id === null) return badRequest(res, 'PATCH requires an id');
176
-
177
- const body = await readBodySafe(req, res);
178
- if (body === null) return;
179
-
180
- const updated = db.updateOne(table, id, body, false);
181
- updated ? json(res, 200, updated) : notFound(res);
182
- }
183
-
184
- function handleDELETE(_req, res, route) {
185
- const { table, id } = route;
186
- if (id === null) return badRequest(res, 'DELETE requires an id');
187
-
188
- const deleted = db.deleteOne(table, id);
189
- deleted ? json(res, 200, {}) : notFound(res);
190
- }
191
-
192
- function handleHealth(res) {
193
- json(res, 200, {
194
- status: 'ok',
195
- /* v8 ignore next */
196
- redis: redis.connected ? 'connected' : 'disconnected',
197
- tables: db.TABLES,
198
- rateLimit: {
199
- enabled: rateLimitEnabled,
200
- max: rateLimitMax,
201
- windowMs: rateLimitWindowMs,
202
- },
203
- });
204
- }
205
-
206
- const authCache = new Map();
207
- const AUTH_CACHE_TTL_MS = 5_000;
208
-
209
- function getCachedAuth(token) {
210
- const entry = authCache.get(token);
211
- if (entry && Date.now() - entry.ts < AUTH_CACHE_TTL_MS) {
212
- return entry.valid;
213
- }
214
- authCache.delete(token);
215
- return undefined;
216
- }
217
-
218
- function setCachedAuth(token, valid) {
219
- /* v8 ignore next 5 */
220
- if (authCache.size > 1000) {
221
- const cutoff = Date.now() - AUTH_CACHE_TTL_MS;
222
- for (const [key, entry] of authCache) {
223
- if (entry.ts < cutoff) authCache.delete(key);
224
- }
225
- }
226
- authCache.set(token, { valid, ts: Date.now() });
227
- }
228
-
229
- function resetAuthCache() {
230
- authCache.clear();
231
- }
232
-
233
- async function checkAdminAuth(req) {
234
- /* v8 ignore next */
235
- if (!adminKey) return false;
236
- const auth = req.headers['authorization'] || '';
237
- const match = auth.match(/^Bearer\s+(.+)$/i);
238
- if (!match) return false;
239
- const token = match[1];
240
- const cached = getCachedAuth(token);
241
- if (cached !== undefined) return cached;
242
- try {
243
- const d = db.getWrappedDb();
244
- const row = d.prepare('SELECT value FROM settings WHERE key = ?').get('ADMIN_KEY');
245
- /* v8 ignore next */
246
- if (!row) return false;
247
- const valid = await argon2.verify(row.value, token);
248
- setCachedAuth(token, valid);
249
- return valid;
250
- } catch {
251
- setCachedAuth(token, false);
252
- return false;
253
- }
254
- }
255
-
256
- async function handleAdmin(req, res, pathname, method) {
257
- if (!(await checkAdminAuth(req))) {
258
- return json(res, 401, { error: 'Unauthorized' });
259
- }
260
-
261
- if (pathname === '/api/admin/settings' && method === 'GET') {
262
- const rows = db.listAll('settings').map((r) => sensitiveKeys.includes(r.key) ? { ...r, value: '***' } : r);
263
- return json(res, 200, rows);
264
- }
265
-
266
- const settingsMatch = pathname.match(/^\/api\/admin\/settings\/(.+)$/);
267
- if (settingsMatch && method === 'PATCH') {
268
- return await handleAdminPatchSetting(req, res, settingsMatch[1]);
269
- }
270
-
271
- if (pathname === '/api/admin/reset-database' && method === 'POST') {
272
- return await handleAdminResetDatabase(req, res);
273
- }
274
-
275
- return notFound(res, `Unknown admin route: ${pathname}`);
276
- }
277
-
278
- async function handleAdminPatchSetting(req, res, settingKey) {
279
- const body = await readBodySafe(req, res);
280
- if (body === null) return;
281
-
282
- if (body.value === undefined) {
283
- return badRequest(res, 'Missing "value" in request body');
284
- }
285
- if (body.value === null || typeof body.value === 'object') {
286
- return badRequest(res, 'Setting value must be a string or number');
287
- }
288
-
289
- const d = db.getWrappedDb();
290
- const existing = d.prepare('SELECT * FROM settings WHERE key = ?').get(settingKey);
291
-
292
- if (!existing) {
293
- const def = SETTING_DEFS.find(s => s.key === settingKey);
294
- if (!def) {
295
- return notFound(res, `Setting '${settingKey}' not found`);
296
- }
297
- const valToStore = settingKey === 'ADMIN_KEY' ? await argon2.hash(body.value) : body.value;
298
- d.prepare(`INSERT INTO settings (key, value, description, updated_at) VALUES (?, ?, ?, datetime('now'))`).run(settingKey, valToStore, def.description);
299
- const created = d.prepare('SELECT * FROM settings WHERE key = ?').get(settingKey);
300
- return json(res, 201, created);
301
- }
302
-
303
- const valToStore = settingKey === 'ADMIN_KEY' ? await argon2.hash(body.value) : body.value;
304
- d.prepare(`UPDATE settings SET value = ?, updated_at = datetime('now') WHERE key = ?`).run(valToStore, settingKey);
305
- const updated = d.prepare('SELECT * FROM settings WHERE key = ?').get(settingKey);
306
- json(res, 200, updated);
307
- }
308
-
309
- let resetLock = Promise.resolve();
310
- const RESET_LOCK_TIMEOUT_MS = 30_000;
311
-
312
- async function withResetLock(fn) {
313
- let release;
314
- let timer;
315
- const prev = resetLock;
316
- resetLock = new Promise((resolve) => { release = resolve; });
317
- await prev;
318
- /* v8 ignore next 2 */
319
- timer = setTimeout(() => { release(); }, RESET_LOCK_TIMEOUT_MS);
320
- try {
321
- return await fn();
322
- } finally {
323
- clearTimeout(timer);
324
- release();
325
- }
326
- }
327
-
328
- async function handleAdminResetDatabase(req, res) {
329
- const body = await readBodySafe(req, res);
330
- if (body === null) return;
331
- if (body.confirm !== true) {
332
- return badRequest(res, 'Reset requires confirm: true in request body');
333
- }
334
- await withResetLock(async () => {
335
- const d = db.getWrappedDb();
336
- d.exec('BEGIN');
337
- try {
338
- const deleteOrder = ['photos', 'comments', 'albums', 'posts', 'todos', 'users'];
339
- for (const table of deleteOrder) {
340
- d.prepare(`DELETE FROM ${table}`).run();
341
- }
342
- /* v8 ignore next */
343
- if (d.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sqlite_sequence'").get()) {
344
- d.exec('DELETE FROM sqlite_sequence');
345
- }
346
- /* v8 ignore next 4 */
347
- const fetchFn = async (url) => {
348
- const response = await globalThis.fetch(url);
349
- return response.json();
350
- };
351
- await seed({ database: d, fetch: fetchFn, runMigrate: false, skipTransaction: true });
352
- d.exec('COMMIT');
353
- json(res, 200, { message: 'Database reset and re-seeded successfully' });
354
- } catch (error) {
355
- d.exec('ROLLBACK');
356
- throw error;
357
- }
358
- });
359
- }
360
-
361
- async function requestHandler(req, res) {
362
- const parsed = new URL(req.url, 'http://localhost');
363
- const pathname = parsed.pathname;
364
- const query = Object.fromEntries(parsed.searchParams);
365
- const method = req.method.toUpperCase();
366
-
367
- if (method === 'OPTIONS') {
368
- res.writeHead(204, {
369
- 'Access-Control-Allow-Origin': '*',
370
- 'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
371
- 'Access-Control-Allow-Headers': 'Content-Type, Authorization',
372
- });
373
- return res.end();
374
- }
375
-
376
- if (pathname === '/health' || pathname === '/api/health') {
377
- return handleHealth(res);
378
- }
379
-
380
- if (pathname === '/' || pathname === '/api') {
381
- return json(res, 200, {
382
- message: 'json-api-server — JSONPlaceholder-compatible REST API',
383
- version: '1.0.0',
384
- endpoints: db.TABLES.map((t) => `/api/${t}`),
385
- docs: 'GET /health for server status',
386
- });
387
- }
388
-
389
- await new Promise((resolve) => {
390
- rateLimiter(req, res, resolve);
391
- });
392
- /* v8 ignore next */
393
- if (res.writableEnded) return;
394
-
395
- if (pathname.startsWith('/api/admin/')) {
396
- try {
397
- return await handleAdmin(req, res, pathname, method);
398
- } catch (err) {
399
- console.error('[Error]', err);
400
- return json(res, 500, { error: 'Internal Server Error', message: err.message });
401
- }
402
- }
403
-
404
- const route = parseRoute(pathname);
405
- if (!route) return notFound(res, `Unknown route: ${pathname}`);
406
- if (route.invalidId) return badRequest(res, 'Invalid ID format');
407
-
408
- try {
409
- switch (method) {
410
- case 'GET': return await handleGET(req, res, route, query);
411
- case 'POST': return await handlePOST(req, res, route);
412
- case 'PUT': return await handlePUT(req, res, route);
413
- case 'PATCH': return await handlePATCH(req, res, route);
414
- case 'DELETE': return handleDELETE(req, res, route);
415
- default:
416
- return json(res, 405, { error: `Method ${method} not allowed` });
417
- }
418
- } catch (err) {
419
- console.error('[Error]', err);
420
- json(res, 500, { error: 'Internal Server Error', message: err.message });
421
- }
422
- }
423
-
424
- const server = http.createServer(requestHandler);
425
-
426
  function printLog() {
427
  const rlText = ` Rate limit: ${rateLimitMax} req / ${rateLimitWindowSec}s (${redis.connected ? 'Redis' : 'Memory'})`.padEnd(50);
428
  console.log(`
@@ -452,27 +60,27 @@ function printLog() {
452
  }
453
 
454
  function startServer() {
455
- if (process.env.START_SERVER !== 'false') { // for testing
456
  server.listen(port, printLog);
457
  }
458
  }
459
 
460
- /* v8 ignore start */
461
  function closeServer() {
462
  return new Promise((resolve) => {
463
  server.close(resolve);
464
  });
465
  }
 
466
  async function shutdown(signal) {
467
  console.log(`\n[Server] ${signal} received — shutting down gracefully...`);
468
  await closeServer();
469
  try { await redis.quit(); } catch { /* ignore */ }
470
  process.exit(0);
471
  }
 
472
  if (process.listenerCount('SIGINT') === 0) {
473
  process.on('SIGINT', () => shutdown('SIGINT'));
474
  process.on('SIGTERM', () => shutdown('SIGTERM'));
475
  }
476
 
477
- /* v8 ignore stop */
478
  module.exports = { server, requestHandler, printLog, closeServer, resetAuthCache };
 
1
  'use strict';
2
 
3
  const http = require('http');
4
+ const fs = require('fs');
5
+ const path = require('path');
6
 
7
+ const { port, redisOpts, rateLimitEnabled, rateLimitMax, rateLimitWindowSec } = require('../config');
 
 
8
  const RedisClient = require('../redis');
9
  const { createRateLimiter } = require('../middleware/rate-limiter');
10
+ const createRouter = require('./route');
 
 
11
 
12
  const redis = new RedisClient(redisOpts);
13
 
14
  const rateLimiter = createRateLimiter(redis, { enabled: rateLimitEnabled });
15
 
16
+ const faviconIco = fs.readFileSync(path.join(__dirname, '..', 'public', 'favicon.ico'));
17
+ const faviconPng = fs.readFileSync(path.join(__dirname, '..', 'public', 'favicon.png'));
18
+
19
+ const { requestHandler, resetAuthCache } = createRouter(rateLimiter, faviconIco, faviconPng, redis);
20
+
21
+ const server = http.createServer(requestHandler);
22
+
23
  (async () => {
24
  try {
25
  await redis.connect();
26
  await redis.ping();
27
  console.log('[Redis] Connected ✓');
28
  } catch (e) {
 
29
  console.warn('[Redis] Unavailable — rate limiting falls back to in-memory:', e.message);
30
  }
31
  startServer();
32
  })();
33
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
34
  function printLog() {
35
  const rlText = ` Rate limit: ${rateLimitMax} req / ${rateLimitWindowSec}s (${redis.connected ? 'Redis' : 'Memory'})`.padEnd(50);
36
  console.log(`
 
60
  }
61
 
62
  function startServer() {
63
+ if (process.env.START_SERVER !== 'false') {
64
  server.listen(port, printLog);
65
  }
66
  }
67
 
 
68
  function closeServer() {
69
  return new Promise((resolve) => {
70
  server.close(resolve);
71
  });
72
  }
73
+
74
  async function shutdown(signal) {
75
  console.log(`\n[Server] ${signal} received — shutting down gracefully...`);
76
  await closeServer();
77
  try { await redis.quit(); } catch { /* ignore */ }
78
  process.exit(0);
79
  }
80
+
81
  if (process.listenerCount('SIGINT') === 0) {
82
  process.on('SIGINT', () => shutdown('SIGINT'));
83
  process.on('SIGTERM', () => shutdown('SIGTERM'));
84
  }
85
 
 
86
  module.exports = { server, requestHandler, printLog, closeServer, resetAuthCache };
src/server/route.js ADDED
@@ -0,0 +1,402 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ 'use strict';
2
+
3
+ const { port, maxBodySize, adminKey, sensitiveKeys, rateLimitEnabled, rateLimitMax, rateLimitWindowMs, rateLimitWindowSec } = require('../config');
4
+ const argon2 = require('argon2');
5
+ const db = require('../db');
6
+ const { seed } = require('../db/seed');
7
+ const { SETTING_DEFS } = require('../db/seed-settings');
8
+
9
+ module.exports = function createRouter(rateLimiter, faviconIco, faviconPng, redis) {
10
+ function json(res, status, data) {
11
+ const body = JSON.stringify(data);
12
+ res.writeHead(status, {
13
+ 'Content-Type': 'application/json; charset=utf-8',
14
+ 'Access-Control-Allow-Origin': '*',
15
+ 'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
16
+ 'Access-Control-Allow-Headers': 'Content-Type, Authorization',
17
+ 'X-Powered-By': 'json-api-server/1.0',
18
+ });
19
+ res.end(body);
20
+ }
21
+
22
+ function notFound(res, msg = 'Not Found') {
23
+ json(res, 404, { error: msg });
24
+ }
25
+
26
+ function badRequest(res, msg = 'Bad Request') {
27
+ json(res, 400, { error: msg });
28
+ }
29
+
30
+ const BODY_TOO_LARGE = Symbol('BODY_TOO_LARGE');
31
+
32
+ function readBody(req, res) {
33
+ return new Promise((resolve, reject) => {
34
+ let body = '';
35
+ req.on('data', (chunk) => {
36
+ body += chunk;
37
+ if (body.length > maxBodySize) {
38
+ json(res, 413, { error: 'Request body too large', message: `Body exceeds ${maxBodySize} bytes limit` });
39
+ req.destroy();
40
+ reject(BODY_TOO_LARGE);
41
+ }
42
+ });
43
+ req.on('end', () => {
44
+ try {
45
+ let parsed = body ? JSON.parse(body) : {};
46
+ if (parsed === null) parsed = {};
47
+ resolve(parsed);
48
+ } catch (_) {
49
+ reject(new Error('Invalid JSON'));
50
+ }
51
+ });
52
+ req.on('error', reject);
53
+ });
54
+ }
55
+
56
+ async function readBodySafe(req, res) {
57
+ try {
58
+ return await readBody(req, res);
59
+ } catch (e) {
60
+ if (e !== BODY_TOO_LARGE) badRequest(res, 'Invalid JSON body');
61
+ }
62
+ return null;
63
+ }
64
+
65
+ function parseRoute(pathname) {
66
+ const parts = pathname.replace(/^\/+|\/+$/g, '').split('/');
67
+ if (parts[0] !== 'api') return null;
68
+ parts.shift();
69
+
70
+ const [table, rawId, sub] = parts;
71
+ const id = rawId ? parseInt(rawId, 10) : null;
72
+
73
+ if (!db.TABLES.includes(table)) return null;
74
+ if (rawId && isNaN(id)) return { invalidId: true };
75
+
76
+ return { table, id, sub };
77
+ }
78
+
79
+ const NESTED = {
80
+ users: { posts: 'userId', albums: 'userId', todos: 'userId' },
81
+ posts: { comments: 'postId' },
82
+ albums: { photos: 'albumId' },
83
+ };
84
+
85
+ async function handleGET(req, res, route, query) {
86
+ const { table, id, sub } = route;
87
+
88
+ for (const param of ['_page', '_limit', '_start', '_end']) {
89
+ if (query[param] !== undefined) {
90
+ if (query[param] === '') {
91
+ delete query[param];
92
+ } else {
93
+ const val = Number(query[param]);
94
+ if (!Number.isInteger(val) || val < 0) {
95
+ return badRequest(res, `Invalid ${param}: must be a non-negative integer`);
96
+ }
97
+ if ((param === '_page' || param === '_limit') && val < 1) {
98
+ return badRequest(res, `Invalid ${param}: must be a positive integer`);
99
+ }
100
+ }
101
+ }
102
+ }
103
+
104
+ if (id !== null && sub) {
105
+ const parentExists = db.getOne(table, id);
106
+ if (!parentExists) return notFound(res);
107
+
108
+ const fkMap = NESTED[table] || {};
109
+ if (!fkMap[sub]) return notFound(res, `No nested route '${sub}' under '${table}'`);
110
+
111
+ const results = db.listAll(sub, { [fkMap[sub]]: String(id), ...query });
112
+ return json(res, 200, results);
113
+ }
114
+
115
+ if (id !== null) {
116
+ const row = db.getOne(table, id);
117
+ return row ? json(res, 200, row) : notFound(res);
118
+ }
119
+
120
+ const rows = db.listAll(table, query);
121
+ json(res, 200, rows);
122
+ }
123
+
124
+ async function handlePOST(req, res, route) {
125
+ const { table } = route;
126
+ const body = await readBodySafe(req, res);
127
+ if (body === null) return;
128
+
129
+ if (!body.id) body.id = db.nextId(table);
130
+
131
+ try {
132
+ const created = db.insertOne(table, body);
133
+ json(res, 201, created);
134
+ } catch (e) {
135
+ badRequest(res, e.message);
136
+ }
137
+ }
138
+
139
+ async function handlePUT(req, res, route) {
140
+ const { table, id } = route;
141
+ if (id === null) return badRequest(res, 'PUT requires an id');
142
+
143
+ const body = await readBodySafe(req, res);
144
+ if (body === null) return;
145
+
146
+ const updated = db.updateOne(table, id, body, true);
147
+ updated ? json(res, 200, updated) : notFound(res);
148
+ }
149
+
150
+ async function handlePATCH(req, res, route) {
151
+ const { table, id } = route;
152
+ if (id === null) return badRequest(res, 'PATCH requires an id');
153
+
154
+ const body = await readBodySafe(req, res);
155
+ if (body === null) return;
156
+
157
+ const updated = db.updateOne(table, id, body, false);
158
+ updated ? json(res, 200, updated) : notFound(res);
159
+ }
160
+
161
+ function handleDELETE(_req, res, route) {
162
+ const { table, id } = route;
163
+ if (id === null) return badRequest(res, 'DELETE requires an id');
164
+
165
+ const deleted = db.deleteOne(table, id);
166
+ deleted ? json(res, 200, {}) : notFound(res);
167
+ }
168
+
169
+ function handleHealth(res) {
170
+ json(res, 200, {
171
+ status: 'ok',
172
+ redis: redis.connected ? 'connected' : 'disconnected',
173
+ tables: db.TABLES,
174
+ rateLimit: {
175
+ enabled: rateLimitEnabled,
176
+ max: rateLimitMax,
177
+ windowMs: rateLimitWindowMs,
178
+ },
179
+ });
180
+ }
181
+
182
+ const authCache = new Map();
183
+ const AUTH_CACHE_TTL_MS = 5_000;
184
+
185
+ function getCachedAuth(token) {
186
+ const entry = authCache.get(token);
187
+ if (entry && Date.now() - entry.ts < AUTH_CACHE_TTL_MS) {
188
+ return entry.valid;
189
+ }
190
+ authCache.delete(token);
191
+ return undefined;
192
+ }
193
+
194
+ function setCachedAuth(token, valid) {
195
+ if (authCache.size > 1000) {
196
+ const cutoff = Date.now() - AUTH_CACHE_TTL_MS;
197
+ for (const [key, entry] of authCache) {
198
+ if (entry.ts < cutoff) authCache.delete(key);
199
+ }
200
+ }
201
+ authCache.set(token, { valid, ts: Date.now() });
202
+ }
203
+
204
+ function resetAuthCache() {
205
+ authCache.clear();
206
+ }
207
+
208
+ async function checkAdminAuth(req) {
209
+ if (!adminKey) return false;
210
+ const auth = req.headers['authorization'] || '';
211
+ const match = auth.match(/^Bearer\s+(.+)$/i);
212
+ if (!match) return false;
213
+ const token = match[1];
214
+ const cached = getCachedAuth(token);
215
+ if (cached !== undefined) return cached;
216
+ try {
217
+ const d = db.getWrappedDb();
218
+ const row = d.prepare('SELECT value FROM settings WHERE key = ?').get('ADMIN_KEY');
219
+ if (!row) return false;
220
+ const valid = await argon2.verify(row.value, token);
221
+ setCachedAuth(token, valid);
222
+ return valid;
223
+ } catch {
224
+ setCachedAuth(token, false);
225
+ return false;
226
+ }
227
+ }
228
+
229
+ async function handleAdmin(req, res, pathname, method) {
230
+ if (!(await checkAdminAuth(req))) {
231
+ return json(res, 401, { error: 'Unauthorized' });
232
+ }
233
+
234
+ if (pathname === '/api/admin/settings' && method === 'GET') {
235
+ const rows = db.listAll('settings').map((r) => sensitiveKeys.includes(r.key) ? { ...r, value: '***' } : r);
236
+ return json(res, 200, rows);
237
+ }
238
+
239
+ const settingsMatch = pathname.match(/^\/api\/admin\/settings\/(.+)$/);
240
+ if (settingsMatch && method === 'PATCH') {
241
+ return await handleAdminPatchSetting(req, res, settingsMatch[1]);
242
+ }
243
+
244
+ if (pathname === '/api/admin/reset-database' && method === 'POST') {
245
+ return await handleAdminResetDatabase(req, res);
246
+ }
247
+
248
+ return notFound(res, `Unknown admin route: ${pathname}`);
249
+ }
250
+
251
+ async function handleAdminPatchSetting(req, res, settingKey) {
252
+ const body = await readBodySafe(req, res);
253
+ if (body === null) return;
254
+
255
+ if (body.value === undefined) {
256
+ return badRequest(res, 'Missing "value" in request body');
257
+ }
258
+ if (body.value === null || typeof body.value === 'object') {
259
+ return badRequest(res, 'Setting value must be a string or number');
260
+ }
261
+
262
+ const d = db.getWrappedDb();
263
+ const existing = d.prepare('SELECT * FROM settings WHERE key = ?').get(settingKey);
264
+
265
+ if (!existing) {
266
+ const def = SETTING_DEFS.find(s => s.key === settingKey);
267
+ /* v8 ignore next */ if (!def) return notFound(res, `Setting '${settingKey}' not found`);
268
+ const valToStore = settingKey === 'ADMIN_KEY' ? await argon2.hash(body.value) : body.value;
269
+ d.prepare(`INSERT INTO settings (key, value, description, updated_at) VALUES (?, ?, ?, datetime('now'))`).run(settingKey, valToStore, def.description);
270
+ const created = d.prepare('SELECT * FROM settings WHERE key = ?').get(settingKey);
271
+ return json(res, 201, created);
272
+ }
273
+
274
+ const valToStore = settingKey === 'ADMIN_KEY' ? await argon2.hash(body.value) : body.value;
275
+ d.prepare(`UPDATE settings SET value = ?, updated_at = datetime('now') WHERE key = ?`).run(valToStore, settingKey);
276
+ const updated = d.prepare('SELECT * FROM settings WHERE key = ?').get(settingKey);
277
+ json(res, 200, updated);
278
+ }
279
+
280
+ let resetLock = Promise.resolve();
281
+ const RESET_LOCK_TIMEOUT_MS = 30_000;
282
+
283
+ async function withResetLock(fn) {
284
+ let release;
285
+ let timer;
286
+ const prev = resetLock;
287
+ resetLock = new Promise((resolve) => { release = resolve; });
288
+ await prev;
289
+ timer = setTimeout(release, RESET_LOCK_TIMEOUT_MS);
290
+ try {
291
+ return await fn();
292
+ } finally {
293
+ clearTimeout(timer);
294
+ release();
295
+ }
296
+ }
297
+
298
+ async function handleAdminResetDatabase(req, res) {
299
+ const body = await readBodySafe(req, res);
300
+ if (body === null) return;
301
+ if (body.confirm !== true) {
302
+ return badRequest(res, 'Reset requires confirm: true in request body');
303
+ }
304
+ await withResetLock(async () => {
305
+ const d = db.getWrappedDb();
306
+ d.exec('BEGIN');
307
+ try {
308
+ const deleteOrder = ['photos', 'comments', 'albums', 'posts', 'todos', 'users'];
309
+ for (const table of deleteOrder) {
310
+ d.prepare(`DELETE FROM ${table}`).run();
311
+ }
312
+ if (d.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sqlite_sequence'").get()) {
313
+ d.exec('DELETE FROM sqlite_sequence');
314
+ }
315
+ const fetchFn = async (url) => {
316
+ const response = await globalThis.fetch(url);
317
+ return response.json();
318
+ };
319
+ await seed({ database: d, fetch: fetchFn, runMigrate: false, skipTransaction: true });
320
+ d.exec('COMMIT');
321
+ json(res, 200, { message: 'Database reset and re-seeded successfully' });
322
+ } catch (error) {
323
+ d.exec('ROLLBACK');
324
+ throw error;
325
+ }
326
+ });
327
+ }
328
+
329
+ async function requestHandler(req, res) {
330
+ const parsed = new URL(req.url, 'http://localhost');
331
+ const pathname = parsed.pathname.length > 1 ? parsed.pathname.replace(/\/+$/, '') : parsed.pathname;
332
+ const query = Object.fromEntries(parsed.searchParams);
333
+ const method = req.method.toUpperCase();
334
+
335
+ if (method === 'OPTIONS') {
336
+ res.writeHead(204, {
337
+ 'Access-Control-Allow-Origin': '*',
338
+ 'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
339
+ 'Access-Control-Allow-Headers': 'Content-Type, Authorization',
340
+ });
341
+ return res.end();
342
+ }
343
+
344
+ if (pathname === '/health' || pathname === '/api/health') {
345
+ return handleHealth(res);
346
+ }
347
+
348
+ if (pathname === '/' || pathname === '/api') {
349
+ return json(res, 200, {
350
+ message: 'Nodejs JSON API Server — JSONPlaceholder-compatible REST API',
351
+ version: '1.0.0',
352
+ endpoints: db.TABLES.map((t) => `/api/${t}`),
353
+ docs: 'GET /health for server status',
354
+ });
355
+ }
356
+
357
+ if (pathname === '/favicon.ico') {
358
+ res.writeHead(200, { 'Content-Type': 'image/x-icon' });
359
+ return res.end(faviconIco);
360
+ }
361
+
362
+ if (pathname === '/favicon.png') {
363
+ res.writeHead(200, { 'Content-Type': 'image/png' });
364
+ return res.end(faviconPng);
365
+ }
366
+
367
+ await new Promise((resolve) => {
368
+ rateLimiter(req, res, resolve);
369
+ });
370
+ if (res.writableEnded) return;
371
+
372
+ if (pathname.startsWith('/api/admin/')) {
373
+ try {
374
+ return await handleAdmin(req, res, pathname, method);
375
+ } catch (err) {
376
+ console.error('[Error]', err);
377
+ return json(res, 500, { error: 'Internal Server Error', message: err.message });
378
+ }
379
+ }
380
+
381
+ const route = parseRoute(pathname);
382
+ /* v8 ignore next */ if (!route) return notFound(res, `Unknown route: ${pathname}`);
383
+ /* v8 ignore next */ if (route.invalidId) return badRequest(res, 'Invalid ID format');
384
+
385
+ try {
386
+ switch (method) {
387
+ case 'GET': return await handleGET(req, res, route, query);
388
+ case 'POST': return await handlePOST(req, res, route);
389
+ case 'PUT': return await handlePUT(req, res, route);
390
+ case 'PATCH': return await handlePATCH(req, res, route);
391
+ case 'DELETE': return handleDELETE(req, res, route);
392
+ default:
393
+ return json(res, 405, { error: `Method ${method} not allowed` });
394
+ }
395
+ } catch (err) {
396
+ console.error('[Error]', err);
397
+ json(res, 500, { error: 'Internal Server Error', message: err.message });
398
+ }
399
+ }
400
+
401
+ return { requestHandler, resetAuthCache };
402
+ };
tests/README.md CHANGED
@@ -33,7 +33,8 @@ tests/
33
  coverage-printlog.test.js # Printlog and server export V8 coverage (4 tests)
34
  graceful-shutdown.test.js # SIGINT/SIGTERM handler coverage (1 test)
35
  integration.test.js # API integration tests — real HTTP + SQLite (77 tests)
36
- server.test.js # Server request handler, admin auth, graceful shutdown (13 tests)
 
37
  helpers/
38
  coverage.js # Shared test utilities (save/restore/setEnv/clearCjs/configMockFactory)
39
  mock-factory.js # Mock factory helpers (mkDb/mkReq/mkRes/mkRedis/mkSettingsTable)
@@ -42,7 +43,7 @@ tests/
42
  seed-settings-coverage.test.js # Seed-settings.js V8 coverage (4 tests)
43
  ```
44
 
45
- **Total: 219 tests across 13 test files.**
46
 
47
  ## Test design
48
 
@@ -61,7 +62,8 @@ Unit tests cover every source module individually. Each module has its own test
61
  | `db/index.js` | `tests/db/database.test.js` | Real `node:sqlite` databases; tests pagination, search, sort, SQL injection |
62
  | `middleware/rate-limiter.js` | `tests/middleware/rate-limiter.test.js` | Module imported once; mocks Redis, in-memory store; tests circuit breaker, proxy IPs, escalating blocks |
63
  | `redis/index.js` | `tests/redis/redis.test.js` | RESP encoding/parsing directly; constructor options |
64
- | `server/index.js` | `tests/server/server.test.js` | `requestHandler()` with mock req/res; CJS cache injection for DB mock; tests auth caching and graceful shutdown (13 tests) |
 
65
  | `server/index.js` (ESM) | `tests/server/coverage-printlog.test.js` | Dynamic `import()` for V8-covered printLog, startServer, 500 catch |
66
  | `server/index.js` (child) | `tests/server/graceful-shutdown.test.js` | SIGINT/SIGTERM via child process (V8 coverage) |
67
  | `db/migrate.js` | `tests/db/migrate.test.js` | Real migration + corrupt DB failure path |
 
33
  coverage-printlog.test.js # Printlog and server export V8 coverage (4 tests)
34
  graceful-shutdown.test.js # SIGINT/SIGTERM handler coverage (1 test)
35
  integration.test.js # API integration tests — real HTTP + SQLite (77 tests)
36
+ index.test.js # Server request handler, admin auth, graceful shutdown (13 tests)
37
+ route.test.js # Route parsing, favicon, health, admin auth cache (14 tests)
38
  helpers/
39
  coverage.js # Shared test utilities (save/restore/setEnv/clearCjs/configMockFactory)
40
  mock-factory.js # Mock factory helpers (mkDb/mkReq/mkRes/mkRedis/mkSettingsTable)
 
43
  seed-settings-coverage.test.js # Seed-settings.js V8 coverage (4 tests)
44
  ```
45
 
46
+ **Total: 233 tests across 14 test files.**
47
 
48
  ## Test design
49
 
 
62
  | `db/index.js` | `tests/db/database.test.js` | Real `node:sqlite` databases; tests pagination, search, sort, SQL injection |
63
  | `middleware/rate-limiter.js` | `tests/middleware/rate-limiter.test.js` | Module imported once; mocks Redis, in-memory store; tests circuit breaker, proxy IPs, escalating blocks |
64
  | `redis/index.js` | `tests/redis/redis.test.js` | RESP encoding/parsing directly; constructor options |
65
+ | `server/index.js` | `tests/server/index.test.js` | `requestHandler()` with mock req/res; CJS cache injection for DB mock; tests auth caching and graceful shutdown (13 tests) |
66
+ | `server/route.js` | `tests/server/route.test.js` | Route parsing, favicon, null body, health endpoint, admin auth, auth cache eviction, reset-database, unknown routes |
67
  | `server/index.js` (ESM) | `tests/server/coverage-printlog.test.js` | Dynamic `import()` for V8-covered printLog, startServer, 500 catch |
68
  | `server/index.js` (child) | `tests/server/graceful-shutdown.test.js` | SIGINT/SIGTERM via child process (V8 coverage) |
69
  | `db/migrate.js` | `tests/db/migrate.test.js` | Real migration + corrupt DB failure path |
tests/seed-settings-coverage.test.js CHANGED
@@ -80,7 +80,7 @@ describe('seed-settings.js', () => {
80
  process.env.DB_PATH = dbPath
81
  process.env.START_SERVER = 'false'
82
 
83
- clearCjs('../src/db/seed-settings.js', '../src/db/index.js', '../src/db/migrate.js', '../src/config/index.js', '../src/server/index.js')
84
  const { seedSettings } = _require('../src/db/seed-settings.js')
85
  await seedSettings()
86
 
 
80
  process.env.DB_PATH = dbPath
81
  process.env.START_SERVER = 'false'
82
 
83
+ clearCjs('../src/db/seed-settings.js', '../src/db/index.js', '../src/db/migrate.js', '../src/config/index.js', '../src/server/index.js', '../src/server/route.js')
84
  const { seedSettings } = _require('../src/db/seed-settings.js')
85
  await seedSettings()
86
 
tests/server/coverage-printlog.test.js CHANGED
@@ -66,7 +66,7 @@ describe('server.js ESM coverage', () => {
66
  process.env.RATE_LIMIT_ENABLED = 'false'
67
  process.env.MAX_BODY_SIZE = '100'
68
 
69
- clearCjs('../../src/config/index.js', '../../src/config/load-env.js')
70
  vi.resetModules()
71
  const mod = await import('../../src/server/index.js')
72
 
@@ -96,7 +96,7 @@ describe('server.js ESM coverage', () => {
96
  process.env.DB_PATH = ':memory:'
97
  process.env.RATE_LIMIT_ENABLED = 'false'
98
 
99
- clearCjs('../../src/config/index.js', '../../src/config/load-env.js')
100
  vi.resetModules()
101
  const mod = await import('../../src/server/index.js')
102
 
@@ -119,7 +119,7 @@ describe('server.js ESM coverage', () => {
119
  process.env.START_SERVER = 'false'
120
  process.env.DB_PATH = ':memory:'
121
 
122
- clearCjs('../../src/config/index.js', '../../src/config/load-env.js')
123
  vi.resetModules()
124
  const mod = await import('../../src/server/index.js')
125
 
 
66
  process.env.RATE_LIMIT_ENABLED = 'false'
67
  process.env.MAX_BODY_SIZE = '100'
68
 
69
+ clearCjs('../../src/config/index.js', '../../src/config/load-env.js', '../../src/server/route.js')
70
  vi.resetModules()
71
  const mod = await import('../../src/server/index.js')
72
 
 
96
  process.env.DB_PATH = ':memory:'
97
  process.env.RATE_LIMIT_ENABLED = 'false'
98
 
99
+ clearCjs('../../src/config/index.js', '../../src/config/load-env.js', '../../src/server/route.js')
100
  vi.resetModules()
101
  const mod = await import('../../src/server/index.js')
102
 
 
119
  process.env.START_SERVER = 'false'
120
  process.env.DB_PATH = ':memory:'
121
 
122
+ clearCjs('../../src/config/index.js', '../../src/config/load-env.js', '../../src/server/route.js')
123
  vi.resetModules()
124
  const mod = await import('../../src/server/index.js')
125
 
tests/server/{server.test.js → index.test.js} RENAMED
@@ -31,7 +31,7 @@ describe('server.js', () => {
31
  listAll: () => { throw new Error('boom') },
32
  insertOne: () => { throw new Error('duplicate') },
33
  })
34
- clearCjs('../../src/server/index.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
35
  const resolvedDb = _require.resolve('../../src/db/index.js')
36
  _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
37
  try {
@@ -67,7 +67,7 @@ describe('server.js', () => {
67
  const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH')
68
  setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: path.join(tmpDir, 'srv-pag.db') })
69
  const mockDb = mkDb()
70
- clearCjs('../../src/server/index.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
71
  const resolvedDb = _require.resolve('../../src/db/index.js')
72
  _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
73
  try {
@@ -94,7 +94,7 @@ describe('server.js', () => {
94
  const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH')
95
  setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: path.join(tmpDir, 'srv-id.db') })
96
  const mockDb = mkDb()
97
- clearCjs('../../src/server/index.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
98
  const resolvedDb = _require.resolve('../../src/db/index.js')
99
  _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
100
  try {
@@ -154,7 +154,7 @@ describe('server.js', () => {
154
  const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
155
 
156
  try {
157
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
158
  vi.resetModules()
159
  const { printLog } = await import('../../src/server/index.js')
160
  printLog()
@@ -165,7 +165,7 @@ describe('server.js', () => {
165
  else delete _require.cache[resolvedRedis]
166
  if (origDbCache) _require.cache[resolvedDb] = origDbCache
167
  else delete _require.cache[resolvedDb]
168
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
169
  }
170
  restore(s)
171
  })
@@ -231,7 +231,7 @@ describe('server.js', () => {
231
  }
232
 
233
  try {
234
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js', '../../src/config/index.js', '../../src/config/load-env.js')
235
  vi.resetModules()
236
  const { requestHandler } = await import('../../src/server/index.js')
237
 
@@ -321,7 +321,7 @@ describe('server.js', () => {
321
  else delete _require.cache[resolvedRedis]
322
  if (origSeedCache) _require.cache[resolvedSeed] = origSeedCache
323
  else delete _require.cache[resolvedSeed]
324
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
325
  }
326
  restore(s)
327
  })
@@ -352,7 +352,7 @@ describe('server.js', () => {
352
  const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
353
 
354
  try {
355
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
356
  vi.resetModules()
357
  await import('../../src/server/index.js')
358
  expect(logSpy).toHaveBeenCalledWith('[Redis] Connected ✓')
@@ -363,7 +363,7 @@ describe('server.js', () => {
363
  else delete _require.cache[resolvedRedis]
364
  if (origDbCache) _require.cache[resolvedDb] = origDbCache
365
  else delete _require.cache[resolvedDb]
366
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
367
  }
368
  restore(s)
369
  })
@@ -381,7 +381,7 @@ describe('server.js', () => {
381
  const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
382
  const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {})
383
 
384
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js', '../../src/redis/index.js')
385
  vi.resetModules()
386
 
387
  const { mockClient, mockRedisClass } = mkRedis()
@@ -416,7 +416,7 @@ describe('server.js', () => {
416
  exitSpy.mockRestore()
417
  if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
418
  else delete _require.cache[resolvedRedis]
419
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
420
  for (const fn of oldSigint) process.on('SIGINT', fn)
421
  for (const fn of oldSigterm) process.on('SIGTERM', fn)
422
  }
@@ -455,7 +455,7 @@ describe('server.js', () => {
455
  _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
456
 
457
  try {
458
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
459
  vi.resetModules()
460
  const { requestHandler } = await import('../../src/server/index.js')
461
 
@@ -484,7 +484,7 @@ describe('server.js', () => {
484
  else delete _require.cache[resolvedDb]
485
  if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
486
  else delete _require.cache[resolvedRedis]
487
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
488
  }
489
  restore(s)
490
  })
@@ -524,7 +524,7 @@ describe('server.js', () => {
524
  _require.cache[resolvedSeed] = { exports: { seed: vi.fn().mockResolvedValue() }, id: resolvedSeed, filename: resolvedSeed, loaded: true }
525
 
526
  try {
527
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
528
  vi.resetModules()
529
  const { requestHandler } = await import('../../src/server/index.js')
530
 
@@ -540,7 +540,7 @@ describe('server.js', () => {
540
  else delete _require.cache[resolvedRedis]
541
  if (origSeedCache) _require.cache[resolvedSeed] = origSeedCache
542
  else delete _require.cache[resolvedSeed]
543
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
544
  }
545
  restore(s)
546
  })
@@ -581,7 +581,7 @@ describe('server.js', () => {
581
  _require.cache[resolvedSeed] = { exports: { seed: vi.fn().mockRejectedValue(new Error('seed fail')) }, id: resolvedSeed, filename: resolvedSeed, loaded: true }
582
 
583
  try {
584
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
585
  vi.resetModules()
586
  const { requestHandler } = await import('../../src/server/index.js')
587
 
@@ -597,7 +597,7 @@ describe('server.js', () => {
597
  if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
598
  else delete _require.cache[resolvedRedis]
599
  delete _require.cache[resolvedSeed]
600
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
601
  }
602
  restore(s)
603
  })
@@ -638,7 +638,7 @@ describe('server.js', () => {
638
  _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
639
 
640
  try {
641
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
642
  vi.resetModules()
643
  const { requestHandler } = await import('../../src/server/index.js')
644
 
@@ -657,7 +657,7 @@ describe('server.js', () => {
657
  else delete _require.cache[resolvedDb]
658
  if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
659
  else delete _require.cache[resolvedRedis]
660
- clearCjs('../../src/server/index.js', '../../src/middleware/rate-limiter.js')
661
  }
662
  restore(s)
663
  })
 
31
  listAll: () => { throw new Error('boom') },
32
  insertOne: () => { throw new Error('duplicate') },
33
  })
34
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
35
  const resolvedDb = _require.resolve('../../src/db/index.js')
36
  _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
37
  try {
 
67
  const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH')
68
  setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: path.join(tmpDir, 'srv-pag.db') })
69
  const mockDb = mkDb()
70
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
71
  const resolvedDb = _require.resolve('../../src/db/index.js')
72
  _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
73
  try {
 
94
  const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH')
95
  setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: path.join(tmpDir, 'srv-id.db') })
96
  const mockDb = mkDb()
97
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
98
  const resolvedDb = _require.resolve('../../src/db/index.js')
99
  _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
100
  try {
 
154
  const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
155
 
156
  try {
157
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
158
  vi.resetModules()
159
  const { printLog } = await import('../../src/server/index.js')
160
  printLog()
 
165
  else delete _require.cache[resolvedRedis]
166
  if (origDbCache) _require.cache[resolvedDb] = origDbCache
167
  else delete _require.cache[resolvedDb]
168
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
169
  }
170
  restore(s)
171
  })
 
231
  }
232
 
233
  try {
234
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js', '../../src/config/index.js', '../../src/config/load-env.js')
235
  vi.resetModules()
236
  const { requestHandler } = await import('../../src/server/index.js')
237
 
 
321
  else delete _require.cache[resolvedRedis]
322
  if (origSeedCache) _require.cache[resolvedSeed] = origSeedCache
323
  else delete _require.cache[resolvedSeed]
324
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
325
  }
326
  restore(s)
327
  })
 
352
  const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
353
 
354
  try {
355
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
356
  vi.resetModules()
357
  await import('../../src/server/index.js')
358
  expect(logSpy).toHaveBeenCalledWith('[Redis] Connected ✓')
 
363
  else delete _require.cache[resolvedRedis]
364
  if (origDbCache) _require.cache[resolvedDb] = origDbCache
365
  else delete _require.cache[resolvedDb]
366
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
367
  }
368
  restore(s)
369
  })
 
381
  const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
382
  const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {})
383
 
384
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js', '../../src/redis/index.js')
385
  vi.resetModules()
386
 
387
  const { mockClient, mockRedisClass } = mkRedis()
 
416
  exitSpy.mockRestore()
417
  if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
418
  else delete _require.cache[resolvedRedis]
419
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
420
  for (const fn of oldSigint) process.on('SIGINT', fn)
421
  for (const fn of oldSigterm) process.on('SIGTERM', fn)
422
  }
 
455
  _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
456
 
457
  try {
458
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
459
  vi.resetModules()
460
  const { requestHandler } = await import('../../src/server/index.js')
461
 
 
484
  else delete _require.cache[resolvedDb]
485
  if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
486
  else delete _require.cache[resolvedRedis]
487
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
488
  }
489
  restore(s)
490
  })
 
524
  _require.cache[resolvedSeed] = { exports: { seed: vi.fn().mockResolvedValue() }, id: resolvedSeed, filename: resolvedSeed, loaded: true }
525
 
526
  try {
527
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
528
  vi.resetModules()
529
  const { requestHandler } = await import('../../src/server/index.js')
530
 
 
540
  else delete _require.cache[resolvedRedis]
541
  if (origSeedCache) _require.cache[resolvedSeed] = origSeedCache
542
  else delete _require.cache[resolvedSeed]
543
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
544
  }
545
  restore(s)
546
  })
 
581
  _require.cache[resolvedSeed] = { exports: { seed: vi.fn().mockRejectedValue(new Error('seed fail')) }, id: resolvedSeed, filename: resolvedSeed, loaded: true }
582
 
583
  try {
584
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
585
  vi.resetModules()
586
  const { requestHandler } = await import('../../src/server/index.js')
587
 
 
597
  if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
598
  else delete _require.cache[resolvedRedis]
599
  delete _require.cache[resolvedSeed]
600
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
601
  }
602
  restore(s)
603
  })
 
638
  _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
639
 
640
  try {
641
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
642
  vi.resetModules()
643
  const { requestHandler } = await import('../../src/server/index.js')
644
 
 
657
  else delete _require.cache[resolvedDb]
658
  if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
659
  else delete _require.cache[resolvedRedis]
660
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
661
  }
662
  restore(s)
663
  })
tests/server/integration.test.js CHANGED
@@ -32,10 +32,22 @@ describe('Health & Root', () => {
32
  expect(res.body.status).toBe('ok');
33
  });
34
 
 
 
 
 
 
 
 
 
 
 
 
 
35
  it('GET / returns API info', async () => {
36
  const res = await request('/');
37
  expect(res.status).toBe(200);
38
- expect(res.body.message).toContain('json-api-server');
39
  expect(res.body.version).toBe('1.0.0');
40
  expect(res.body.endpoints).toBeInstanceOf(Array);
41
  });
@@ -45,6 +57,12 @@ describe('Health & Root', () => {
45
  expect(res.status).toBe(200);
46
  expect(res.body.version).toBe('1.0.0');
47
  });
 
 
 
 
 
 
48
  });
49
 
50
  describe('CORS', () => {
@@ -146,6 +164,18 @@ describe('404 handling', () => {
146
  expect(res.status).toBe(404);
147
  expect(res.body.error).toContain('Unknown route');
148
  });
 
 
 
 
 
 
 
 
 
 
 
 
149
  });
150
 
151
  describe('400 handling', () => {
 
32
  expect(res.body.status).toBe('ok');
33
  });
34
 
35
+ it('GET /health/ works with trailing slash', async () => {
36
+ const res = await request('/health/');
37
+ expect(res.status).toBe(200);
38
+ expect(res.body.status).toBe('ok');
39
+ });
40
+
41
+ it('GET /api/health/ works with trailing slash', async () => {
42
+ const res = await request('/api/health/');
43
+ expect(res.status).toBe(200);
44
+ expect(res.body.status).toBe('ok');
45
+ });
46
+
47
  it('GET / returns API info', async () => {
48
  const res = await request('/');
49
  expect(res.status).toBe(200);
50
+ expect(res.body.message).toContain('JSON API Server');
51
  expect(res.body.version).toBe('1.0.0');
52
  expect(res.body.endpoints).toBeInstanceOf(Array);
53
  });
 
57
  expect(res.status).toBe(200);
58
  expect(res.body.version).toBe('1.0.0');
59
  });
60
+
61
+ it('GET /api/ works with trailing slash', async () => {
62
+ const res = await request('/api/');
63
+ expect(res.status).toBe(200);
64
+ expect(res.body.version).toBe('1.0.0');
65
+ });
66
  });
67
 
68
  describe('CORS', () => {
 
164
  expect(res.status).toBe(404);
165
  expect(res.body.error).toContain('Unknown route');
166
  });
167
+
168
+ it('GET /users without /api prefix returns 404', async () => {
169
+ const res = await request('/users');
170
+ expect(res.status).toBe(404);
171
+ expect(res.body.error).toContain('Unknown route');
172
+ });
173
+
174
+ it('GET /api/users/ with trailing slash still works', async () => {
175
+ const res = await request('/api/users/');
176
+ expect(res.status).toBe(200);
177
+ expect(Array.isArray(res.body)).toBe(true);
178
+ });
179
  });
180
 
181
  describe('400 handling', () => {
tests/server/route.test.js ADDED
@@ -0,0 +1,557 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import { describe, it, expect, vi, afterAll } from 'vitest'
2
+ import fs from 'fs'
3
+ import path from 'path'
4
+ import { mkdtempSync } from 'fs'
5
+ import { tmpdir } from 'os'
6
+ import { createRequire } from 'module'
7
+ import { save, restore, setEnv, configMockFactory } from '../helpers/coverage'
8
+ import { mkDb, mkRedis, mkReq, mkRes } from '../helpers/mock-factory'
9
+
10
+ const tmpDir = mkdtempSync(path.join(tmpdir(), 'cov-rt-'))
11
+ const _require = createRequire(import.meta.url)
12
+ function clearCjs(...keys) {
13
+ for (const key of keys) {
14
+ const resolved = _require.resolve(key)
15
+ if (_require.cache[resolved]) delete _require.cache[resolved]
16
+ }
17
+ }
18
+
19
+ afterAll(() => {
20
+ try { fs.rmSync(tmpDir, { recursive: true, force: true }) } catch {}
21
+ })
22
+
23
+ vi.mock('../../src/config/load-env.js', () => ({ loadEnv: () => {} }))
24
+ vi.mock('../../src/config/index.js', () => configMockFactory())
25
+
26
+ describe('route.js', () => {
27
+ it('serves favicon.ico and favicon.png', async () => {
28
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL')
29
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '' })
30
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
31
+ vi.resetModules()
32
+ const { requestHandler } = await import('../../src/server/index.js')
33
+
34
+ const resIco = mkRes()
35
+ await requestHandler(mkReq('/favicon.ico'), resIco)
36
+ expect(resIco.writeHead).toHaveBeenCalledWith(200, expect.objectContaining({ 'Content-Type': 'image/x-icon' }))
37
+
38
+ const resPng = mkRes()
39
+ await requestHandler(mkReq('/favicon.png'), resPng)
40
+ expect(resPng.writeHead).toHaveBeenCalledWith(200, expect.objectContaining({ 'Content-Type': 'image/png' }))
41
+
42
+ restore(s)
43
+ })
44
+
45
+ it('handles JSON body "null" by converting to empty object', async () => {
46
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH')
47
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:' })
48
+ const mockDb = mkDb({ insertOne: vi.fn((table, body) => ({ id: 1, ...body })) })
49
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
50
+ const resolvedDb = _require.resolve('../../src/db/index.js')
51
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
52
+ try {
53
+ vi.resetModules()
54
+ const { requestHandler } = await import('../../src/server/index.js')
55
+
56
+ const res = mkRes()
57
+ await requestHandler(mkReq('/api/users', 'POST', {}, 'null'), res)
58
+ expect(res.writeHead).toHaveBeenCalledWith(201, expect.anything())
59
+ const body = JSON.parse(res.end.mock.calls[0][0])
60
+ expect(body).toEqual({ id: 1 })
61
+ } finally {
62
+ delete _require.cache[resolvedDb]
63
+ }
64
+ restore(s)
65
+ })
66
+
67
+ it('returns 401 for admin routes when ADMIN_KEY is not configured', async () => {
68
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH', 'ADMIN_KEY')
69
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:', ADMIN_KEY: '' })
70
+ const mockDb = mkDb()
71
+ const resolvedConfig = _require.resolve('../../src/config/index.js')
72
+ const origConfigCache = _require.cache[resolvedConfig]
73
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js', '../../src/config/index.js')
74
+ const resolvedDb = _require.resolve('../../src/db/index.js')
75
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
76
+ try {
77
+ vi.resetModules()
78
+ const { requestHandler } = await import('../../src/server/index.js')
79
+
80
+ const res = mkRes()
81
+ await requestHandler(mkReq('/api/admin/settings', 'GET', { authorization: 'Bearer any-key' }), res)
82
+ expect(res.writeHead).toHaveBeenCalledWith(401, expect.anything())
83
+ } finally {
84
+ delete _require.cache[resolvedDb]
85
+ if (origConfigCache) _require.cache[resolvedConfig] = origConfigCache
86
+ else delete _require.cache[resolvedConfig]
87
+ }
88
+ restore(s)
89
+ })
90
+
91
+ it('returns 401 when settings row is missing for ADMIN_KEY', async () => {
92
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH', 'ADMIN_KEY')
93
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:', ADMIN_KEY: 'secret' })
94
+
95
+ const argon2 = _require('argon2')
96
+ const verifySpy = vi.spyOn(argon2, 'verify').mockResolvedValue(true)
97
+
98
+ const mockDb = mkDb({
99
+ getWrappedDb: () => ({
100
+ prepare: (sql) => {
101
+ if (sql.includes('SELECT value FROM settings')) return { get: () => null }
102
+ return { all: () => [], get: () => null, run: () => {} }
103
+ },
104
+ exec: () => {},
105
+ }),
106
+ TABLES: ['users', 'posts', 'comments', 'albums', 'photos', 'todos', 'settings'],
107
+ })
108
+
109
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
110
+ const resolvedDb = _require.resolve('../../src/db/index.js')
111
+ const resolvedRedis = _require.resolve('../../src/redis/index.js')
112
+ const { mockRedisClass } = mkRedis()
113
+ const origDbCache = _require.cache[resolvedDb]
114
+ const origRedisCache = _require.cache[resolvedRedis]
115
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
116
+ _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
117
+
118
+ try {
119
+ vi.resetModules()
120
+ const { requestHandler } = await import('../../src/server/index.js')
121
+
122
+ const res = mkRes()
123
+ await requestHandler(mkReq('/api/admin/settings', 'GET', { authorization: 'Bearer secret' }), res)
124
+ expect(res.writeHead).toHaveBeenCalledWith(401, expect.anything())
125
+ expect(verifySpy).not.toHaveBeenCalled()
126
+ } finally {
127
+ verifySpy.mockRestore()
128
+ if (origDbCache) _require.cache[resolvedDb] = origDbCache
129
+ else delete _require.cache[resolvedDb]
130
+ if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
131
+ else delete _require.cache[resolvedRedis]
132
+ }
133
+ restore(s)
134
+ })
135
+
136
+ it('cleans up auth cache when it exceeds 1000 entries', async () => {
137
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH', 'ADMIN_KEY')
138
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:', ADMIN_KEY: 'secret', RATE_LIMIT_ENABLED: 'false' })
139
+
140
+ const argon2 = _require('argon2')
141
+ const origVerify = argon2.verify
142
+ const origHash = argon2.hash
143
+ argon2.verify = vi.fn().mockResolvedValue(true)
144
+ argon2.hash = vi.fn().mockResolvedValue('$argon2id$hash')
145
+
146
+ const settingsTable = [
147
+ { key: 'ADMIN_KEY', value: '$argon2id$hash', description: 'Admin key', updated_at: '2025-01-01' },
148
+ ]
149
+ const mockDb = mkDb({
150
+ getWrappedDb: () => ({
151
+ prepare: (sql) => {
152
+ if (sql.includes('SELECT value FROM settings')) return { get: () => settingsTable[0] }
153
+ return { all: () => settingsTable, get: () => null, run: () => {} }
154
+ },
155
+ exec: () => {},
156
+ }),
157
+ listAll: () => settingsTable,
158
+ TABLES: ['users', 'posts', 'comments', 'albums', 'photos', 'todos', 'settings'],
159
+ })
160
+
161
+ const resolvedConfig = _require.resolve('../../src/config/index.js')
162
+ const origConfigCache = _require.cache[resolvedConfig]
163
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js', '../../src/config/index.js')
164
+ const resolvedDb = _require.resolve('../../src/db/index.js')
165
+ const resolvedRedis = _require.resolve('../../src/redis/index.js')
166
+ const { mockRedisClass } = mkRedis()
167
+ const origDbCache = _require.cache[resolvedDb]
168
+ const origRedisCache = _require.cache[resolvedRedis]
169
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
170
+ _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
171
+
172
+ try {
173
+ vi.resetModules()
174
+ const { requestHandler } = await import('../../src/server/index.js')
175
+
176
+ const promises = []
177
+ for (let i = 0; i < 1002; i++) {
178
+ const res = mkRes()
179
+ const req = mkReq('/api/admin/settings', 'GET', { authorization: `Bearer token-${i}` })
180
+ promises.push(requestHandler(req, res).then(() => {
181
+ expect(res.writeHead).toHaveBeenCalledWith(200, expect.anything())
182
+ }))
183
+ }
184
+ await Promise.all(promises)
185
+ } finally {
186
+ argon2.verify = origVerify
187
+ argon2.hash = origHash
188
+ if (origDbCache) _require.cache[resolvedDb] = origDbCache
189
+ else delete _require.cache[resolvedDb]
190
+ if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
191
+ else delete _require.cache[resolvedRedis]
192
+ if (origConfigCache) _require.cache[resolvedConfig] = origConfigCache
193
+ else delete _require.cache[resolvedConfig]
194
+ }
195
+ restore(s)
196
+ })
197
+
198
+ it('covers auth cache cleanup deleting expired entries', async () => {
199
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH', 'ADMIN_KEY')
200
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:', ADMIN_KEY: 'secret', RATE_LIMIT_ENABLED: 'false' })
201
+
202
+ let fakeNow = 0
203
+ const dateNowSpy = vi.spyOn(Date, 'now').mockImplementation(() => fakeNow)
204
+
205
+ const argon2 = _require('argon2')
206
+ const origVerify = argon2.verify
207
+ const origHash = argon2.hash
208
+ argon2.verify = vi.fn().mockResolvedValue(true)
209
+ argon2.hash = vi.fn().mockResolvedValue('$argon2id$hash')
210
+
211
+ const settingsTable = [
212
+ { key: 'ADMIN_KEY', value: '$argon2id$hash', description: 'Admin key', updated_at: '2025-01-01' },
213
+ ]
214
+ const mockDb = mkDb({
215
+ getWrappedDb: () => ({
216
+ prepare: (sql) => {
217
+ if (sql.includes('SELECT value FROM settings')) return { get: () => settingsTable[0] }
218
+ return { all: () => settingsTable, get: () => null, run: () => {} }
219
+ },
220
+ exec: () => {},
221
+ }),
222
+ listAll: () => settingsTable,
223
+ TABLES: ['users', 'posts', 'comments', 'albums', 'photos', 'todos', 'settings'],
224
+ })
225
+
226
+ const resolvedConfig = _require.resolve('../../src/config/index.js')
227
+ const origConfigCache = _require.cache[resolvedConfig]
228
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js', '../../src/config/index.js')
229
+ const resolvedDb = _require.resolve('../../src/db/index.js')
230
+ const resolvedRedis = _require.resolve('../../src/redis/index.js')
231
+ const { mockRedisClass } = mkRedis()
232
+ const origDbCache = _require.cache[resolvedDb]
233
+ const origRedisCache = _require.cache[resolvedRedis]
234
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
235
+ _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
236
+
237
+ try {
238
+ vi.resetModules()
239
+ const { requestHandler } = await import('../../src/server/index.js')
240
+
241
+ fakeNow = 0
242
+ for (let i = 0; i < 1001; i++) {
243
+ const res = mkRes()
244
+ await requestHandler(mkReq('/api/admin/settings', 'GET', { authorization: `Bearer token-${i}` }), res)
245
+ expect(res.writeHead).toHaveBeenCalledWith(200, expect.anything())
246
+ }
247
+
248
+ fakeNow = 6000
249
+ const resLast = mkRes()
250
+ await requestHandler(mkReq('/api/admin/settings', 'GET', { authorization: 'Bearer token-final' }), resLast)
251
+ expect(resLast.writeHead).toHaveBeenCalledWith(200, expect.anything())
252
+ } finally {
253
+ dateNowSpy.mockRestore()
254
+ argon2.verify = origVerify
255
+ argon2.hash = origHash
256
+ if (origDbCache) _require.cache[resolvedDb] = origDbCache
257
+ else delete _require.cache[resolvedDb]
258
+ if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
259
+ else delete _require.cache[resolvedRedis]
260
+ if (origConfigCache) _require.cache[resolvedConfig] = origConfigCache
261
+ else delete _require.cache[resolvedConfig]
262
+ }
263
+ restore(s)
264
+ })
265
+
266
+ it('covers sqlite_sequence cleanup in reset-database', async () => {
267
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH', 'ADMIN_KEY')
268
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:', ADMIN_KEY: 'secret' })
269
+
270
+ const argon2 = _require('argon2')
271
+ const origVerify = argon2.verify
272
+ const origHash = argon2.hash
273
+ argon2.verify = vi.fn().mockResolvedValue(true)
274
+ argon2.hash = vi.fn().mockResolvedValue('$argon2id$mockhash')
275
+
276
+ let execCalls = []
277
+ const wrappedDb = {
278
+ prepare: (sql) => {
279
+ if (sql.includes('SELECT value FROM settings')) return { get: () => ({ value: '$argon2id$mockhash' }) }
280
+ if (sql.includes('sqlite_sequence')) return { get: () => ({ name: 'sqlite_sequence' }) }
281
+ return { all: () => [], get: () => null, run: () => {} }
282
+ },
283
+ exec: vi.fn((sql) => { execCalls.push(sql) }),
284
+ }
285
+ const mockDb = mkDb({
286
+ getWrappedDb: () => wrappedDb,
287
+ listAll: () => [{ key: 'foo', value: 'bar' }],
288
+ TABLES: ['users', 'posts', 'comments', 'albums', 'photos', 'todos', 'settings'],
289
+ })
290
+
291
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
292
+ const resolvedDb = _require.resolve('../../src/db/index.js')
293
+ const resolvedRedis = _require.resolve('../../src/redis/index.js')
294
+ const resolvedSeed = _require.resolve('../../src/db/seed.js')
295
+ const { mockRedisClass } = mkRedis()
296
+ const origDbCache = _require.cache[resolvedDb]
297
+ const origRedisCache = _require.cache[resolvedRedis]
298
+ const origSeedCache = _require.cache[resolvedSeed]
299
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
300
+ _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
301
+ _require.cache[resolvedSeed] = { exports: { seed: vi.fn().mockResolvedValue() }, id: resolvedSeed, filename: resolvedSeed, loaded: true }
302
+
303
+ try {
304
+ vi.resetModules()
305
+ const { requestHandler } = await import('../../src/server/index.js')
306
+
307
+ const res = mkRes()
308
+ await requestHandler(mkReq('/api/admin/reset-database', 'POST', { authorization: 'Bearer secret' }, JSON.stringify({ confirm: true })), res)
309
+ expect(res.writeHead).toHaveBeenCalledWith(200, expect.anything())
310
+ expect(execCalls).toContain('DELETE FROM sqlite_sequence')
311
+ } finally {
312
+ argon2.verify = origVerify
313
+ argon2.hash = origHash
314
+ if (origDbCache) _require.cache[resolvedDb] = origDbCache
315
+ else delete _require.cache[resolvedDb]
316
+ if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
317
+ else delete _require.cache[resolvedRedis]
318
+ if (origSeedCache) _require.cache[resolvedSeed] = origSeedCache
319
+ else delete _require.cache[resolvedSeed]
320
+ }
321
+ restore(s)
322
+ })
323
+
324
+ it('returns 404 for routes without /api prefix', async () => {
325
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH')
326
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:' })
327
+ const mockDb = mkDb()
328
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
329
+ const resolvedDb = _require.resolve('../../src/db/index.js')
330
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
331
+ try {
332
+ vi.resetModules()
333
+ const { requestHandler } = await import('../../src/server/index.js')
334
+
335
+ const res = mkRes()
336
+ await requestHandler(mkReq('/users', 'GET'), res)
337
+ expect(res.writeHead).toHaveBeenCalledWith(404, expect.anything())
338
+
339
+ const resSlash = mkRes()
340
+ await requestHandler(mkReq('/users/', 'GET'), resSlash)
341
+ expect(resSlash.writeHead).toHaveBeenCalledWith(404, expect.anything())
342
+ } finally {
343
+ delete _require.cache[resolvedDb]
344
+ }
345
+ restore(s)
346
+ })
347
+
348
+ it('covers redis connected in health endpoint', async () => {
349
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL')
350
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '' })
351
+ const { mockRedisClass } = mkRedis({ connected: true })
352
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/redis/index.js', '../../src/middleware/rate-limiter.js')
353
+ const resolvedRedis = _require.resolve('../../src/redis/index.js')
354
+ const origRedisCache = _require.cache[resolvedRedis]
355
+ _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
356
+ try {
357
+ vi.resetModules()
358
+ const { requestHandler } = await import('../../src/server/index.js')
359
+
360
+ const res = mkRes()
361
+ await requestHandler(mkReq('/health'), res)
362
+ expect(res.writeHead).toHaveBeenCalledWith(200, expect.anything())
363
+ const body = JSON.parse(res.end.mock.calls[0][0])
364
+ expect(body.redis).toBe('connected')
365
+ } finally {
366
+ if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
367
+ else delete _require.cache[resolvedRedis]
368
+ }
369
+ restore(s)
370
+ })
371
+
372
+ it('covers resetAuthCache export', async () => {
373
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL')
374
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '' })
375
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/middleware/rate-limiter.js')
376
+ vi.resetModules()
377
+ const { requestHandler, resetAuthCache } = await import('../../src/server/index.js')
378
+
379
+ expect(typeof resetAuthCache).toBe('function')
380
+ expect(() => resetAuthCache()).not.toThrow()
381
+ restore(s)
382
+ })
383
+
384
+ it('covers PATCH setting with unknown key', async () => {
385
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH', 'ADMIN_KEY')
386
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:', ADMIN_KEY: 'secret', RATE_LIMIT_ENABLED: 'false' })
387
+
388
+ const argon2 = _require('argon2')
389
+ const origVerify = argon2.verify
390
+ const origHash = argon2.hash
391
+ argon2.verify = vi.fn().mockResolvedValue(true)
392
+ argon2.hash = vi.fn().mockResolvedValue('$argon2id$hash')
393
+
394
+ const settingsTable = [
395
+ { key: 'ADMIN_KEY', value: '$argon2id$hash', description: 'Admin key', updated_at: '2025-01-01' },
396
+ ]
397
+ const mockDb = mkDb({
398
+ getWrappedDb: () => ({
399
+ prepare: (sql) => {
400
+ if (sql.includes('SELECT value FROM settings')) return { get: () => settingsTable[0] }
401
+ return { all: () => settingsTable, get: () => null, run: () => {} }
402
+ },
403
+ exec: () => {},
404
+ }),
405
+ listAll: () => settingsTable,
406
+ TABLES: ['users', 'posts', 'comments', 'albums', 'photos', 'todos', 'settings'],
407
+ })
408
+
409
+ const resolvedConfig = _require.resolve('../../src/config/index.js')
410
+ const origConfigCache = _require.cache[resolvedConfig]
411
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js', '../../src/config/index.js')
412
+ const resolvedDb = _require.resolve('../../src/db/index.js')
413
+ const resolvedRedis = _require.resolve('../../src/redis/index.js')
414
+ const { mockRedisClass } = mkRedis()
415
+ const origDbCache = _require.cache[resolvedDb]
416
+ const origRedisCache = _require.cache[resolvedRedis]
417
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
418
+ _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
419
+
420
+ try {
421
+ vi.resetModules()
422
+ const { requestHandler } = await import('../../src/server/index.js')
423
+
424
+ const res = mkRes()
425
+ await requestHandler(mkReq('/api/admin/settings/nonExistentKey', 'PATCH', { authorization: 'Bearer secret' }, JSON.stringify({ value: 'new-value' })), res)
426
+ expect(res.writeHead).toHaveBeenCalledWith(404, expect.anything())
427
+ } finally {
428
+ argon2.verify = origVerify
429
+ argon2.hash = origHash
430
+ if (origDbCache) _require.cache[resolvedDb] = origDbCache
431
+ else delete _require.cache[resolvedDb]
432
+ if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
433
+ else delete _require.cache[resolvedRedis]
434
+ if (origConfigCache) _require.cache[resolvedConfig] = origConfigCache
435
+ else delete _require.cache[resolvedConfig]
436
+ }
437
+ restore(s)
438
+ })
439
+
440
+ it('covers invalid ID format in URL', async () => {
441
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH')
442
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:' })
443
+ const mockDb = mkDb()
444
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
445
+ const resolvedDb = _require.resolve('../../src/db/index.js')
446
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
447
+ try {
448
+ vi.resetModules()
449
+ const { requestHandler } = await import('../../src/server/index.js')
450
+
451
+ const res = mkRes()
452
+ await requestHandler(mkReq('/api/users/abc', 'GET'), res)
453
+ expect(res.writeHead).toHaveBeenCalledWith(400, expect.anything())
454
+ } finally {
455
+ delete _require.cache[resolvedDb]
456
+ }
457
+ restore(s)
458
+ })
459
+
460
+ it('covers unknown route not in TABLES', async () => {
461
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH')
462
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:' })
463
+ const mockDb = mkDb({ TABLES: ['users', 'posts', 'comments', 'albums', 'photos', 'todos'] })
464
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
465
+ const resolvedDb = _require.resolve('../../src/db/index.js')
466
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
467
+ try {
468
+ vi.resetModules()
469
+ const { requestHandler } = await import('../../src/server/index.js')
470
+
471
+ const res = mkRes()
472
+ await requestHandler(mkReq('/api/extras', 'GET'), res)
473
+ expect(res.writeHead).toHaveBeenCalledWith(404, expect.anything())
474
+ } finally {
475
+ delete _require.cache[resolvedDb]
476
+ }
477
+ restore(s)
478
+ })
479
+
480
+ it('covers remaining route.js branches together', async () => {
481
+ const s = save('START_SERVER', 'PORT', 'REDIS_URL', 'DB_PATH', 'ADMIN_KEY')
482
+ setEnv({ START_SERVER: 'false', PORT: '0', REDIS_URL: '', DB_PATH: ':memory:', ADMIN_KEY: 'secret' })
483
+
484
+ const argon2 = _require('argon2')
485
+ const origVerify = argon2.verify
486
+ const origHash = argon2.hash
487
+ argon2.verify = vi.fn().mockResolvedValue(true)
488
+ argon2.hash = vi.fn().mockResolvedValue('$argon2id$hash')
489
+
490
+ const settingsTable = [
491
+ { key: 'ADMIN_KEY', value: '$argon2id$hash', description: 'Admin key', updated_at: '2025-01-01' },
492
+ ]
493
+ const mockDb = mkDb({
494
+ getWrappedDb: () => ({
495
+ prepare: (sql) => {
496
+ if (sql.includes('SELECT value FROM settings')) return { get: () => settingsTable[0] }
497
+ return { all: () => settingsTable, get: () => null, run: () => {} }
498
+ },
499
+ exec: () => {},
500
+ }),
501
+ listAll: () => settingsTable,
502
+ getOne: () => ({ id: 1, name: 'Alice' }),
503
+ TABLES: ['users', 'posts', 'comments', 'albums', 'photos', 'todos', 'settings'],
504
+ })
505
+
506
+ clearCjs('../../src/server/index.js', '../../src/server/route.js', '../../src/db/index.js', '../../src/middleware/rate-limiter.js')
507
+ const resolvedDb = _require.resolve('../../src/db/index.js')
508
+ const resolvedRedis = _require.resolve('../../src/redis/index.js')
509
+ const { mockRedisClass } = mkRedis()
510
+ const origDbCache = _require.cache[resolvedDb]
511
+ const origRedisCache = _require.cache[resolvedRedis]
512
+ _require.cache[resolvedDb] = { exports: mockDb, id: resolvedDb, filename: resolvedDb, loaded: true }
513
+ _require.cache[resolvedRedis] = { exports: mockRedisClass, id: resolvedRedis, filename: resolvedRedis, loaded: true }
514
+
515
+ try {
516
+ vi.resetModules()
517
+ const { requestHandler } = await import('../../src/server/index.js')
518
+
519
+ const res1 = mkRes()
520
+ await requestHandler(mkReq('/api/admin/settings/nonExistentKey', 'PATCH', { authorization: 'Bearer secret' }, JSON.stringify({ value: 'x' })), res1)
521
+ expect(res1.writeHead).toHaveBeenCalledWith(404, expect.anything())
522
+
523
+ const res2 = mkRes()
524
+ await requestHandler(mkReq('/api/extras', 'GET'), res2)
525
+ expect(res2.writeHead).toHaveBeenCalledWith(404, expect.anything())
526
+
527
+ const res3 = mkRes()
528
+ await requestHandler(mkReq('/api/users/abc', 'GET'), res3)
529
+ expect(res3.writeHead).toHaveBeenCalledWith(400, expect.anything())
530
+
531
+ const res4 = mkRes()
532
+ res4.writableEnded = true
533
+ await requestHandler(mkReq('/api/users', 'GET'), res4)
534
+ expect(res4.writeHead).not.toHaveBeenCalled()
535
+
536
+ const res5 = mkRes()
537
+ await requestHandler(mkReq('/api/users', 'GET'), res5)
538
+ expect(res5.writeHead).toHaveBeenCalledWith(200, expect.anything())
539
+
540
+ const res6 = mkRes()
541
+ await requestHandler(mkReq('/api/users/1', 'GET'), res6)
542
+ expect(res6.writeHead).toHaveBeenCalledWith(200, expect.anything())
543
+
544
+ const res7 = mkRes()
545
+ await requestHandler(mkReq('/api/admin/settings/DEFAULT_PAGE_SIZE', 'PATCH', { authorization: 'Bearer secret' }, JSON.stringify({ value: 20 })), res7)
546
+ expect(res7.writeHead).toHaveBeenCalledWith(201, expect.anything())
547
+ } finally {
548
+ argon2.verify = origVerify
549
+ argon2.hash = origHash
550
+ if (origDbCache) _require.cache[resolvedDb] = origDbCache
551
+ else delete _require.cache[resolvedDb]
552
+ if (origRedisCache) _require.cache[resolvedRedis] = origRedisCache
553
+ else delete _require.cache[resolvedRedis]
554
+ }
555
+ restore(s)
556
+ })
557
+ })