Upstream/server/index.js
jvanvik b56b13880e Stage 0-2 server spine: db, scheduler, REST, auth, economy, map
Built: SQLite (node:sqlite) via server/db.js with checksummed migrations, injectable clock, persistent event
scheduler with catch-up, tiny REST router (error envelope, idempotency keys, rate limits, bearer tokens with scrypt
passwords), lazy-resource economy in public/js/rules.js + data.js, build/cancel/rename commands, seeded map +
spawn ring, generated docs/openapi.json. NETWALL net.js/static.js reused.
Tested: manual smoke run only (signup, town view, build, map). No unit tests or e2e yet.
NOT done: military, expansion, social, client, push, deploy docs, bots/admin.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Q2MJaQ5LXAHzGnTDgceT14
2026-10-11 18:07:42 +02:00

132 lines
6.3 KiB
JavaScript

'use strict';
/*
* UPSTREAM server: static client + REST API under /api/v1 + (stage 6) WebSocket push, one SQLite file.
* See docs/API.md, docs/DEPLOY.md.
*
* const { createServer } = require('./server');
* const srv = await createServer({ port: 8080, dbPath: './data/game.db' }); // srv.port, srv.close(), srv.db, ...
*
* Run directly: PORT=8080 HOST=:: DB_PATH=./data/game.db TRUST_PROXY=auto ALLOWED_ORIGINS=https://game.example.com node server/index.js
*/
const http = require('http');
const path = require('path');
const { openDb, migrate } = require('./db');
const { RealClock } = require('./clock');
const { Scheduler } = require('./scheduler');
const { createCommands } = require('./commands');
const { createQueries } = require('./queries');
const { createApi } = require('./http');
const { createAuth } = require('./auth');
const { ensureWorld } = require('./world');
const routes = require('./routes');
const eventHandlers = require('./events');
const { createStaticHandler, applySecurityHeaders } = require('./static');
const { parseTrustProxy, parseTrustedProxies, listenDual, listUrls } = require('./net');
function defaultLog(msg) { console.log(new Date().toISOString() + ' ' + msg); }
async function createServer(userOpts) {
const o = {
port: 8080, host: '::', publicDir: path.join(__dirname, '..', 'public'), dbPath: process.env.DB_PATH || './data/game.db',
trustProxy: 'auto', trustedProxies: null, allowedOrigins: [], maxConnPerIp: 40, log: defaultLog,
clock: null, autoArm: true, signupCode: process.env.SIGNUP_CODE || '',
world: { speed: Number(process.env.WORLD_SPEED) || undefined, mapRadius: Number(process.env.WORLD_RADIUS) || undefined, name: process.env.WORLD_NAME || undefined },
};
for (const k of Object.keys(userOpts || {})) if (userOpts[k] !== undefined) o[k] = userOpts[k];
o.trustProxy = parseTrustProxy(o.trustProxy);
o.trustedProxies = parseTrustedProxies(o.trustedProxies);
const log = typeof o.log === 'function' ? o.log : () => {};
const clock = o.clock || new RealClock();
const db = openDb(o.dbPath);
const applied = migrate(db);
if (applied.length) log('applied migrations: ' + applied.join(', '));
const worldId = ensureWorld(db, clock.now(), o.world);
if (worldId) log('created world ' + worldId);
const scheduler = new Scheduler({ db, clock, handlers: eventHandlers, log, autoArm: o.autoArm });
const caught = scheduler.catchUp(); // everything overdue, in order, before accepting traffic
if (caught) log('caught up ' + caught + ' overdue event(s)');
const commands = createCommands({ db, clock, scheduler });
const queries = createQueries({ db, clock, scheduler });
const auth = createAuth({ db });
const api = createApi({ db, clock, log, opts: o, auth });
const services = { db, clock, scheduler, commands, queries, auth, opts: o, log };
routes.register(api.router, services);
api.services = services;
const serveStatic = createStaticHandler(o.publicDir);
const server = http.createServer((req, res) => {
const url = req.url || '/';
if (url === '/healthz' || url.startsWith('/healthz?')) {
applySecurityHeaders(res);
res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': 'no-store' });
return res.end(req.method === 'HEAD' ? undefined : 'ok');
}
if (url.startsWith('/api/')) return api.handle(req, res);
return serveStatic(req, res).catch((err) => { log('static error: ' + (err && err.message)); if (!res.headersSent) res.writeHead(500); res.end(); });
});
server.headersTimeout = 20000; server.requestTimeout = 30000; server.keepAliveTimeout = 5000;
const sockets = new Set();
server.on('connection', (s) => { sockets.add(s); s.on('close', () => sockets.delete(s)); });
const bound = await listenDual(server, o.port, o.host, log);
const port = server.address().port;
scheduler.arm();
const idemTimer = setInterval(() => { try { api.pruneIdempotency(); } catch (e) { log('prune failed: ' + e.message); } }, 3600 * 1000);
idemTimer.unref();
let closePromise = null;
function close() {
if (closePromise) return closePromise;
closePromise = (async () => {
scheduler.stop(); clearInterval(idemTimer);
await new Promise((r) => { server.close(() => r()); if (server.closeIdleConnections) server.closeIdleConnections(); setTimeout(() => { for (const s of sockets) s.destroy(); }, 1000).unref(); });
db.close();
})();
return closePromise;
}
return Object.assign(services, { port, host: bound, server, api, close, options: o });
}
function envInt(name, def) {
const v = process.env[name];
if (v === undefined || v === '') return def;
const n = Number(v);
if (!Number.isInteger(n) || n < 0) throw new Error(name + ' must be a non-negative integer (got ' + JSON.stringify(v) + ')');
return n;
}
async function main() {
const opts = {
port: envInt('PORT', 8080), host: process.env.HOST || '::',
trustProxy: process.env.TRUST_PROXY || 'auto', trustedProxies: process.env.TRUSTED_PROXIES || '',
allowedOrigins: (process.env.ALLOWED_ORIGINS || '').split(',').map((s) => s.trim()).filter(Boolean),
};
if (process.env.MAX_CONN_PER_IP) opts.maxConnPerIp = envInt('MAX_CONN_PER_IP', 40);
const srv = await createServer(opts);
console.log('UPSTREAM is listening on ' + (srv.host.includes(':') ? '[' + srv.host + ']' : srv.host) + ':' + srv.port +
(srv.host === '::' ? ' (dual stack: IPv4 + IPv6)' : srv.host === '0.0.0.0' ? ' (IPv4 only)' : ''));
console.log(' database: ' + path.resolve(srv.options.dbPath));
console.log('Open:');
for (const u of listUrls(srv.host, srv.port)) console.log(' ' + u);
let stopping = false;
const stop = (sig) => {
if (stopping) { console.log('second ' + sig + ', exiting now'); process.exit(0); }
stopping = true;
console.log('received ' + sig + ', shutting down');
const force = setTimeout(() => { console.log('shutdown timed out, exiting'); process.exit(0); }, 5000);
force.unref();
srv.close().then(() => process.exit(0), (err) => { console.error(err); process.exit(0); });
};
process.on('SIGINT', () => stop('SIGINT'));
process.on('SIGTERM', () => stop('SIGTERM'));
}
module.exports = { createServer };
if (require.main === module) {
main().catch((err) => { console.error('UPSTREAM failed to start: ' + (err && err.message || err)); process.exit(1); });
}