@prosopo/client-example-server 2.7.122 → 2.7.124

package/src/app.ts

@@ -14,6 +14,7 @@
 
 import fs from "node:fs";
 import http from "node:http";
+import type { Server } from "node:http";
 import https from "node:https";
 import type { ServerOptions } from "node:https";
 import path from "node:path";
@@ -22,41 +23,50 @@ import { ProsopoEnvError } from "@prosopo/common";
 import { loadEnv } from "@prosopo/dotenv";
 import { getLogger } from "@prosopo/logger";
 import { getServerConfig } from "@prosopo/server";
-import { at } from "@prosopo/util";
+import type { ProsopoServerConfigOutput } from "@prosopo/types";
+import { at, isMain } from "@prosopo/util";
 import cors from "cors";
 import express from "express";
 import routesFactory from "./routes/routes.js";
 import connectionFactory from "./utils/connection.js";
 import memoryServerSetup from "./utils/database.js";
 
-loadEnv();
-
-enum ProsopoVerificationType {
+export enum ProsopoVerificationType {
 	api = "api",
 	local = "local",
 }
 
 const logger = getLogger("info", "client-example-server:app");
 
-async function main() {
-	loadEnv();
-
+/**
+ * The siteverify endpoint the deployment talks to. Non-production
+ * environments get their name as a subdomain prefix. An unset NODE_ENV is
+ * treated as production: prefixing it produced `undefined-api.prosopo.io`,
+ * a host that does not exist.
+ */
+export const resolveVerifyEndpoint = (): string => {
+	const environment = process.env.NODE_ENV;
 	const apiPrefix =
-		process.env.NODE_ENV && process.env.NODE_ENV === "production"
-			? ""
-			: `${process.env.NODE_ENV}-`;
-	const verifyEndpoint =
+		!environment || environment === "production" ? "" : `${environment}-`;
+	return (
 		process.env.PROSOPO_VERIFY_ENDPOINT ||
-		`https://${apiPrefix}api.prosopo.io/siteverify`;
-
-	logger.info(() => ({ data: { verifyEndpoint } }));
-
-	const verifyType: ProsopoVerificationType = Object.keys(
-		ProsopoVerificationType,
-	).includes(process.env.PROSOPO_VERIFICATION_TYPE as string)
+		`https://${apiPrefix}api.prosopo.io/siteverify`
+	);
+};
+
+/** Anything the enum doesn't name falls back to the hosted API. */
+export const resolveVerifyType = (): ProsopoVerificationType =>
+	Object.keys(ProsopoVerificationType).includes(
+		process.env.PROSOPO_VERIFICATION_TYPE as string,
+	)
 		? (process.env.PROSOPO_VERIFICATION_TYPE as ProsopoVerificationType)
 		: ProsopoVerificationType.api;
 
+export const isDevelopmentOrTest = (): boolean =>
+	process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+
+/** The express app, minus the routes, which need a database connection. */
+export const createApp = (): express.Express => {
 	const app = express();
 
 	// https://express-rate-limit.mintlify.app/guides/troubleshooting-proxy-issues
@@ -81,15 +91,79 @@ async function main() {
 		next();
 	});
 
-	app.options("/*", (_, res) => {
-		res.sendStatus(200);
+	// No explicit OPTIONS handler: cors() above already answers preflight
+	// requests with a 204 and never calls through, so the handler that used to
+	// sit here could not run.
+
+	return app;
+};
+
+export const DEFAULT_PORT = 9228;
+
+/**
+ * The port is the last segment of the configured server URL. A URL without
+ * one used to yield NaN, which node turns into an arbitrary free port — the
+ * server came up on an address nothing was configured to talk to.
+ */
+export const resolvePort = (config: ProsopoServerConfigOutput): number => {
+	if (!config.serverUrl) return DEFAULT_PORT;
+	const segments = config.serverUrl.split(":");
+	if (segments.length < 3) return DEFAULT_PORT;
+	const port = Number.parseInt(at(segments, 2));
+	return Number.isNaN(port) ? DEFAULT_PORT : port;
+};
+
+/**
+ * HTTPS in development/test when the repo's certificates exist, plain HTTP
+ * otherwise — in production Caddy terminates TLS.
+ */
+export const startServer = (
+	app: express.Express,
+	port: number,
+	dirname: string = path.dirname(fileURLToPath(import.meta.url)),
+): Server => {
+	if (isDevelopmentOrTest()) {
+		const certsDir = path.resolve(dirname, "../../../certs");
+
+		const keyPath = path.join(certsDir, "server.key");
+		const certPath = path.join(certsDir, "server.crt");
+
+		if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
+			const httpsOptions: ServerOptions = {
+				key: fs.readFileSync(keyPath),
+				cert: fs.readFileSync(certPath),
+			};
+
+			return https.createServer(httpsOptions, app).listen(port, () => {
+				logger.info(() => ({ msg: `HTTPS server started on port ${port}` }));
+			});
+		}
+		logger.warn(() => ({
+			msg: "Certificates not found, starting HTTP server instead. Run ./setup_certs.sh to enable HTTPS in development.",
+		}));
+		return http.createServer(app).listen(port, () => {
+			logger.info(() => ({ msg: `HTTP server started on port ${port}` }));
+		});
+	}
+	return http.createServer(app).listen(port, () => {
+		logger.info(() => ({
+			msg: `HTTP server started on port ${port} (TLS handled by reverse proxy)`,
+		}));
 	});
+};
+
+export async function main(): Promise<Server> {
+	loadEnv();
 
-	if (
-		!process.env.MONGO_URI &&
-		process.env.NODE_ENV !== "development" &&
-		process.env.NODE_ENV !== "test"
-	) {
+	const verifyEndpoint = resolveVerifyEndpoint();
+
+	logger.info(() => ({ data: { verifyEndpoint } }));
+
+	const verifyType = resolveVerifyType();
+
+	const app = createApp();
+
+	if (!process.env.MONGO_URI && !isDevelopmentOrTest()) {
 		throw new Error(
 			"Cannot run mongo memory when NODE_ENV is neither development nor test",
 		);
@@ -113,57 +187,24 @@ async function main() {
 
 	app.use(routesFactory(mongoose, config, verifyEndpoint, verifyType));
 
-	const port = config.serverUrl
-		? Number.parseInt(at(config.serverUrl.split(":"), 2))
-		: 9228;
+	const port = resolvePort(config);
 
 	logger.info(() => ({ msg: "Listening on port", data: { port } }));
 
-	// Use HTTPS only in development/test when we have certificates
-	// In production, use HTTP because Caddy handles TLS termination
-	const isDev =
-		process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
-
-	if (isDev) {
-		const __filename = fileURLToPath(import.meta.url);
-		const __dirname = path.dirname(__filename);
-		const certsDir = path.resolve(__dirname, "../../../certs");
-
-		const keyPath = path.join(certsDir, "server.key");
-		const certPath = path.join(certsDir, "server.crt");
-
-		if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
-			const httpsOptions: ServerOptions = {
-				key: fs.readFileSync(keyPath),
-				cert: fs.readFileSync(certPath),
-			};
+	return startServer(app, port);
+}
 
-			https.createServer(httpsOptions, app).listen(port, () => {
-				logger.info(() => ({ msg: `HTTPS server started on port ${port}` }));
-			});
-		} else {
-			logger.warn(() => ({
-				msg: "Certificates not found, starting HTTP server instead. Run ./setup_certs.sh to enable HTTPS in development.",
-			}));
-			http.createServer(app).listen(port, () => {
-				logger.info(() => ({ msg: `HTTP server started on port ${port}` }));
-			});
-		}
-	} else {
-		// Production: use plain HTTP, Caddy handles TLS
-		http.createServer(app).listen(port, () => {
-			logger.info(() => ({
-				msg: `HTTP server started on port ${port} (TLS handled by reverse proxy)`,
-			}));
+// Only boot when run as a binary: importing this module (a test, or another
+// entrypoint reusing createApp) must not open a port or spin up mongo.
+if (isMain(import.meta.url)) {
+	main()
+		.then(() => {
+			logger.info(() => ({ msg: "Server started" }));
+		})
+		.catch((err) => {
+			logger.error(() => ({ err }));
+			// Non-zero, so a boot failure is visible to whatever supervises the
+			// process rather than reading as a clean shutdown.
+			process.exit(1);
 		});
-	}
 }
-
-main()
-	.then(() => {
-		logger.info(() => ({ msg: "Server started" }));
-	})
-	.catch((err) => {
-		logger.error(() => ({ err }));
-		process.exit();
-	});

package/src/controllers/auth.ts

@@ -85,9 +85,6 @@ const getPairAndSecretForSiteKey = (
 	]) {
 		const newSecret = `${baseSecret}//${captchaType}`;
 		pair = getPair(newSecret);
-		console.log(
-			`[PAIR CHECK] Checking pair for ${captchaType}: ${pair?.address} (expected: ${siteKey})`,
-		);
 		logger.info(() => ({
 			msg: "Checking pair",
 			data: {
@@ -97,7 +94,6 @@ const getPairAndSecretForSiteKey = (
 			},
 		}));
 		if (pair.address === siteKey) {
-			console.log(`[PAIR CHECK] ✅ Match found for ${captchaType}!`);
 			secret = newSecret;
 			break;
 		}
@@ -236,29 +232,29 @@ const signup = async (
 			const salt = randomAsHex(32);
 			// !!!DUMMY CODE!!! - Do not use in production. Use bcrypt or similar for password hashing.
 			const passwordHash = hashPassword(`${req.body.password}${salt}`);
-			if (passwordHash) {
-				return User.create({
-					email: email,
-					name: req.body.name,
-					password: passwordHash,
-					salt: salt,
+			// No `if (passwordHash)` guard: the hash is always a non-empty hex
+			// string, and the guard's absent else-branch left the request hanging
+			// with no response at all.
+			return User.create({
+				email: email,
+				name: req.body.name,
+				password: passwordHash,
+				salt: salt,
+			})
+				.then(() => {
+					res.status(200).json({ message: "user created" });
 				})
-					.then(() => {
-						res.status(200).json({ message: "user created" });
-					})
-					.catch((err) => {
-						logger.error(() => ({
-							err,
-							msg: "Error creating user in database",
-						}));
-						res.status(502).json({ message: "error while creating the user" });
-					});
-			}
-		} else {
-			res
-				.status(401)
-				.json({ message: "user has not completed a captcha", verified });
+				.catch((err) => {
+					logger.error(() => ({
+						err,
+						msg: "Error creating user in database",
+					}));
+					res.status(502).json({ message: "error while creating the user" });
+				});
 		}
+		res
+			.status(401)
+			.json({ message: "user has not completed a captcha", verified });
 	} catch (err) {
 		console.error("error", err);
 		res
@@ -347,25 +343,38 @@ const login = async (
 
 const isAuth = (req: Request, res: Response) => {
 	const authHeader = req.get("Authorization") || "";
+	// Each branch returns: without the returns a missing header still fell
+	// through to `at(headerParts, 1)`, which throws on a one-element array, and
+	// a failed verify sent a 500 followed by a 401 on the same response.
 	if (!authHeader) {
-		res.status(401).json({ message: "not authenticated" });
+		return res.status(401).json({ message: "not authenticated" });
+	}
+
+	const headerParts = authHeader.split(" ");
+	if (headerParts.length < 2) {
+		return res.status(401).json({ message: "not authenticated" });
+	}
+
+	const token = at(headerParts, 1);
+	// "Bearer " with nothing after it is a malformed credential, not a server
+	// fault: jwt.verify("") throws and would otherwise surface as a 500.
+	if (!token) {
+		return res.status(401).json({ message: "not authenticated" });
 	}
 
-	const token = at(authHeader.split(" "), 1);
 	let decodedToken: string | JwtPayload = "";
 	try {
 		decodedToken = jwt.verify(token, "secret");
 	} catch (err) {
-		res.status(500).json({
+		return res.status(500).json({
 			message: (err as Error).message || "could not decode the token",
 		});
 	}
 
 	if (!decodedToken) {
-		res.status(401).json({ message: "unauthorized" });
-	} else {
-		res.status(200).json({ message: "here is your resource" });
+		return res.status(401).json({ message: "unauthorized" });
 	}
+	return res.status(200).json({ message: "here is your resource" });
 };
 
 export { signup, login, isAuth };

package/src/routes/routes.ts

@@ -16,14 +16,17 @@ import express from "express";
 import type { Connection } from "mongoose";
 import { isAuth, login, signup } from "../controllers/auth.js";
 
-const router = express.Router();
-
 function getRoutes(
 	mongoose: Connection,
 	config: ProsopoServerConfigOutput,
 	verifyEndpoint: string,
 	verifyType: string,
 ): express.Router {
+	// A router per call: the module-level singleton this used to share meant a
+	// second getRoutes() stacked another set of handlers onto the same router,
+	// so every request ran the first call's bound config.
+	const router = express.Router();
+
 	router.post(
 		"/login",
 		login.bind(null, mongoose, config, verifyEndpoint, verifyType),