@prosopo/provider-mock 2.8.190 → 2.8.192

package/src/api.ts

@@ -1,208 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import type { IncomingHttpHeaders } from "node:http";
-import { ProsopoApiError } from "@prosopo/common";
-import { type Logger, getLogger } from "@prosopo/logger";
-import { getJA4 } from "@prosopo/provider";
-import {
-	ClientApiPaths,
-	type ProcaptchaOutput,
-	type ProcaptchaToken,
-	VerifySolutionBody,
-	decodeProcaptchaOutput,
-} from "@prosopo/types";
-import type { VerifySolutionBodyTypeOutput } from "@prosopo/types";
-import express, { type RequestHandler, type Router } from "express";
-import { rateLimit } from "express-rate-limit";
-import { JA4Database, type JA4Store } from "./db.js";
-import { verifyProcaptchaOutput } from "./verify.js";
-
-/** Just enough of an express request for the handlers below. */
-export interface ApiRequest {
-	body: unknown;
-	headers: IncomingHttpHeaders;
-	t: (key: string) => string;
-}
-
-/** Just enough of an express response for the handlers below. */
-export interface ApiResponse {
-	json: (body: object) => unknown;
-	status: (code: number) => { send: (body: string) => unknown };
-}
-
-export type ApiNext = (error: unknown) => void;
-
-export interface RouterDeps {
-	db: JA4Store;
-	getJA4: (
-		headers: IncomingHttpHeaders,
-		logger?: Logger,
-	) => Promise<{ ja4PlusFingerprint: string }>;
-	decodeToken: (token: ProcaptchaToken) => ProcaptchaOutput;
-	logger: Logger;
-}
-
-export const DEFAULT_MONGO_URL = "mongodb://localhost:27017";
-export const DEFAULT_MONGO_DBNAME = "client";
-export const DEFAULT_MONGO_AUTH_SOURCE = "admin";
-
-export const createDatabase = (
-	env: NodeJS.ProcessEnv = process.env,
-): JA4Database =>
-	new JA4Database(
-		env.MONGO_URL || DEFAULT_MONGO_URL,
-		env.MONGO_DBNAME || DEFAULT_MONGO_DBNAME,
-		env.MONGO_AUTH_SOURCE || DEFAULT_MONGO_AUTH_SOURCE,
-	);
-
-export const defaultRouterDeps = (): RouterDeps => ({
-	db: createDatabase(),
-	getJA4,
-	decodeToken: decodeProcaptchaOutput,
-	logger: getLogger("info", "provider-mock:api"),
-});
-
-/**
- * Verify a solution, as the real provider would.
- *
- * A body that does not parse is the caller's fault and is reported as a 400; a
- * token that parses but cannot be decoded is reported as a 500, because at that
- * point the request looked well formed and the mock cannot tell the difference
- * between a corrupt token and a bug of its own.
- */
-export const createVerifyHandler =
-	(deps: RouterDeps) =>
-	async (req: ApiRequest, res: ApiResponse, next: ApiNext): Promise<void> => {
-		let body: VerifySolutionBodyTypeOutput;
-		try {
-			body = VerifySolutionBody.parse(req.body);
-		} catch (err) {
-			return next(
-				new ProsopoApiError("CAPTCHA.PARSE_ERROR", {
-					context: { error: err, code: 400 },
-					logLevel: "info",
-				}),
-			);
-		}
-		try {
-			const outcome = verifyProcaptchaOutput(deps.decodeToken(body.token));
-			res.json({
-				status: req.t(outcome.statusMessage),
-				verified: outcome.verified,
-				...(outcome.commitmentId === undefined
-					? {}
-					: { commitmentId: outcome.commitmentId }),
-			});
-		} catch (err) {
-			return next(
-				new ProsopoApiError("API.UNKNOWN", {
-					context: { error: err, code: 500 },
-				}),
-			);
-		}
-	};
-
-/** Record the caller's JA4 fingerprint and hand it back to them. */
-export const createTestHandler =
-	(deps: RouterDeps) =>
-	async (req: ApiRequest, res: ApiResponse): Promise<void> => {
-		try {
-			const { ja4PlusFingerprint } = await deps.getJA4(
-				req.headers,
-				deps.logger,
-			);
-			try {
-				await deps.db.connect();
-				await deps.db.addOrUpdateJA4Record({
-					ja4_fingerprint: ja4PlusFingerprint,
-					user_agent_string: req.headers["user-agent"] || "",
-				});
-			} finally {
-				// The close used to be skipped whenever anything above it threw, so
-				// every failing request leaked its connection.
-				await deps.db.close();
-			}
-			res.json({
-				ja4: ja4PlusFingerprint,
-				ua: req.headers["user-agent"],
-			});
-		} catch (e) {
-			// The block above fingerprints and then writes to mongo, so naming
-			// ClientHello here reported a database outage as a parse failure.
-			deps.logger.error(() => ({
-				err: e instanceof Error ? e : new Error(String(e)),
-				msg: "Failed to record the caller's JA4 fingerprint",
-			}));
-			res.status(500).send("Failed to record the caller's JA4 fingerprint.");
-		}
-	};
-
-/**
- * Both routes do unauthenticated work on the caller's behalf — one verifies a
- * token, the other writes a fingerprint to mongo — so an unthrottled client can
- * drive the database as fast as it can send. The window is generous enough that
- * the demos and cypress runs never see it.
- */
-export const verifyRateLimit = (): RequestHandler =>
-	rateLimit({
-		windowMs: 60_000,
-		limit: 600,
-		standardHeaders: true,
-		legacyHeaders: false,
-	});
-
-/**
- * Adapt a handler written against the narrow request/response types above to
- * the express signature. Express hands the same objects through untouched; the
- * narrow types exist only so tests can pass plain objects.
- */
-export const toRequestHandler = (
-	handler: (req: ApiRequest, res: ApiResponse, next: ApiNext) => Promise<void>,
-): RequestHandler => {
-	const adapted: RequestHandler = (req, res, next): void => {
-		// Express ignores a returned promise, so a rejection here would surface as
-		// an unhandled rejection and the request would hang; hand it to the error
-		// middleware instead.
-		handler(
-			req as unknown as ApiRequest,
-			res as unknown as ApiResponse,
-			next,
-		).catch(next);
-	};
-	return adapted;
-};
-
-/**
- * Returns a router connected to the database which can interact with the Proposo protocol
- *
- * @return {Router} - A middleware router that can interact with the Prosopo protocol
- */
-export function prosopoRouter(deps: RouterDeps = defaultRouterDeps()): Router {
-	const router = express.Router();
-
-	router.post(
-		ClientApiPaths.VerifyImageCaptchaSolutionDapp,
-		verifyRateLimit(),
-		toRequestHandler(createVerifyHandler(deps)),
-	);
-
-	router.get(
-		"/test",
-		verifyRateLimit(),
-		toRequestHandler(createTestHandler(deps)),
-	);
-
-	return router;
-}

package/src/db.ts

@@ -1,168 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { ProsopoDBError } from "@prosopo/common";
-import { MongoDatabase } from "@prosopo/database";
-import type { Logger } from "@prosopo/logger";
-import type { Tables } from "@prosopo/types-database";
-import type mongoose from "mongoose";
-import { Schema } from "mongoose";
-
-export enum TableNames {
-	ja4 = "ja4",
-}
-
-export type JA4Data = {
-	application?: string;
-	library?: string;
-	device?: string;
-	os?: string;
-	user_agent_string: string;
-	certificate_authority?: string;
-	observation_count?: number;
-	verified?: boolean;
-	notes?: string;
-	ja4_fingerprint: string;
-	ja4_fingerprint_string?: string;
-	ja4s_fingerprint?: string;
-	ja4h_fingerprint?: string;
-	ja4x_fingerprint?: string;
-	ja4t_fingerprint?: string;
-	ja4ts_fingerprint?: string;
-	ja4tscan_fingerprint?: string;
-};
-
-export type JA4Record = JA4Data & mongoose.Document;
-
-/**
- * The slice of the database the API depends on.
- *
- * Narrower than JA4Database so a caller — a test, or a different storage
- * backend — can supply one without a mongo connection.
- */
-export interface JA4Store {
-	connect: () => Promise<void>;
-	close: () => Promise<void>;
-	addOrUpdateJA4Record: (record: JA4Data) => Promise<JA4Record | null>;
-}
-
-const JA4Schema = new Schema({
-	application: String,
-	library: String,
-	device: String,
-	os: String,
-	user_agent_string: String,
-	certificate_authority: String,
-	observation_count: { type: Number, default: 1 },
-	verified: { type: Boolean, default: false },
-	notes: { type: String, default: "" },
-	ja4_fingerprint: { type: String, required: true },
-	ja4_fingerprint_string: String,
-	ja4s_fingerprint: String,
-	ja4h_fingerprint: String,
-	ja4x_fingerprint: String,
-	ja4t_fingerprint: String,
-	ja4ts_fingerprint: String,
-	ja4tscan_fingerprint: String,
-});
-
-JA4Schema.index({ ja4_fingerprint: 1, user_agent_string: 1 }, { unique: true });
-
-const DATA_TABLES = [
-	{
-		collectionName: TableNames.ja4,
-		modelName: TableNames.ja4,
-		schema: JA4Schema,
-	},
-];
-
-export class JA4Database extends MongoDatabase {
-	tables: Tables<TableNames>;
-
-	constructor(
-		url: string,
-		dbname?: string,
-		authSource?: string,
-		logger?: Logger,
-	) {
-		super(url, dbname, authSource, logger);
-		this.tables = {} as Tables<TableNames>;
-	}
-
-	override async connect(): Promise<void> {
-		await super.connect();
-		const connection = this.connection;
-		if (connection === undefined) {
-			// super.connect() resolves only once the connection is open, so this
-			// cannot normally happen — but the models below would be read off
-			// undefined if it ever did, which is a worse error to debug.
-			throw new ProsopoDBError("DATABASE.CONNECTION_UNDEFINED", {
-				context: { failedFuncName: this.connect.name },
-				logger: this.logger,
-			});
-		}
-		for (const { collectionName, modelName, schema } of DATA_TABLES) {
-			this.tables[collectionName] = connection.model(modelName, schema);
-		}
-	}
-
-	/**
-	 * The registered models.
-	 *
-	 * The check used to be `!this.tables`, which the constructor makes
-	 * impossible, so querying before connect() failed with a TypeError on
-	 * undefined rather than the database error it is.
-	 */
-	getTables(): Tables<TableNames> {
-		if (this.tables[TableNames.ja4] === undefined) {
-			throw new ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
-				context: { failedFuncName: this.getTables.name },
-				logger: this.logger,
-			});
-		}
-		return this.tables;
-	}
-
-	async getJA4Records(): Promise<JA4Record[]> {
-		return this.getTables().ja4.find<JA4Record>({});
-	}
-
-	async getJA4RecordByFingerprintAndUserAgent(
-		ja4Fingerprint: string,
-		userAgentString: string,
-	): Promise<JA4Record | null> {
-		return this.getTables().ja4.findOne<JA4Record>({
-			ja4_fingerprint: ja4Fingerprint,
-			user_agent_string: userAgentString,
-		});
-	}
-
-	// add a ja4 record or update an existing one if the user agent string and ja4 fingerprint match, incrementing the observation count
-
-	async addOrUpdateJA4Record(ja4Record: JA4Data): Promise<JA4Record | null> {
-		const existingRecord = await this.getJA4RecordByFingerprintAndUserAgent(
-			ja4Record.ja4_fingerprint,
-			ja4Record.user_agent_string ? ja4Record.user_agent_string : "",
-		);
-		if (existingRecord) {
-			existingRecord.observation_count =
-				(existingRecord.observation_count || 0) + 1;
-			await existingRecord.save();
-			return existingRecord;
-		}
-		const newRecord = new (this.getTables().ja4)(ja4Record);
-		await newRecord.save();
-		return newRecord;
-	}
-}

package/src/index.ts

@@ -1,18 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-export * from "./api.js";
-export * from "./db.js";
-export * from "./isMain.js";
-export * from "./verify.js";

package/src/isMain.ts

@@ -1,37 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { resolve } from "node:path";
-import { argv } from "node:process";
-import { fileURLToPath } from "node:url";
-
-/**
- * Whether the module at moduleUrl is the one node was asked to run.
- *
- * Guards the module's side effects so importing it — for its exports, or from a
- * test — does not start a server.
- */
-export const isMain = (
-	moduleUrl: string,
-	entrypoint: string | undefined = argv[1],
-): boolean => {
-	if (entrypoint === undefined) {
-		return false;
-	}
-	// argv[1] is whatever was typed, so `node ./dist/start.js` gives a relative
-	// path while the module url is always absolute. Resolve before comparing or
-	// the guard is false for every relative entrypoint and the server never
-	// starts.
-	return fileURLToPath(moduleUrl) === resolve(entrypoint);
-};

package/src/start.ts

@@ -1,117 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { handleErrors } from "@prosopo/api-express-router";
-import { i18nMiddleware } from "@prosopo/locale";
-import { LogLevel, type Logger, getLogger } from "@prosopo/logger";
-import cors from "cors";
-import express, { type Express, type RequestHandler } from "express";
-import { type RouterDeps, prosopoRouter } from "./api.js";
-import { isMain } from "./isMain.js";
-
-export const DEFAULT_API_PORT = 9229;
-
-type Router = ReturnType<typeof prosopoRouter>;
-
-export interface StartDeps {
-	createApp: () => Express;
-	i18n: () => Promise<RequestHandler>;
-	router: (deps?: RouterDeps) => Router;
-	logger: Logger;
-	port: number;
-	exit: (code: number) => void;
-}
-
-export const defaultStartDeps = (
-	env: NodeJS.ProcessEnv = process.env,
-): StartDeps => ({
-	createApp: express,
-	i18n: () => i18nMiddleware({}),
-	router: prosopoRouter,
-	logger: getLogger(LogLevel.enum.info, "prosopo:provider-mock:start.ts"),
-	port: readPort(env),
-	exit: (code: number): void => {
-		process.exit(code);
-	},
-});
-
-/**
- * The port to listen on.
- *
- * The port used to be the string "9229" with no way to change it, so the mock
- * could not be run twice on one machine. A value that is not a usable port is
- * ignored rather than passed to listen, where it would either throw or — for a
- * number out of range — bind somewhere unexpected.
- */
-export const readPort = (env: NodeJS.ProcessEnv): number => {
-	const raw = env.PROVIDER_MOCK_PORT;
-	if (raw === undefined || raw.trim() === "") {
-		return DEFAULT_API_PORT;
-	}
-	const port = Number(raw);
-	if (!Number.isInteger(port) || port < 0 || port > 65535) {
-		return DEFAULT_API_PORT;
-	}
-	return port;
-};
-
-export const startApi = async (
-	deps: StartDeps = defaultStartDeps(),
-): Promise<Express> => {
-	const apiApp = deps.createApp();
-
-	apiApp.use(cors());
-	apiApp.use(express.json());
-	apiApp.use(await deps.i18n());
-	apiApp.use(deps.router());
-	apiApp.use(handleErrors);
-
-	// listen() reports a failed bind (EADDRINUSE and friends) on the server's
-	// error event, not by throwing, so returning straight after calling it left
-	// main()'s try/catch with nothing to catch. Settle on whichever event fires
-	// first instead.
-	const server = apiApp.listen(deps.port);
-	await new Promise<void>((resolvePromise, rejectPromise) => {
-		server.once("listening", () => {
-			server.removeListener("error", rejectPromise);
-			deps.logger.info(() => ({
-				msg: `Prosopo app listening at http://localhost:${deps.port}`,
-			}));
-			resolvePromise();
-		});
-		server.once("error", rejectPromise);
-	});
-
-	return apiApp;
-};
-
-export const main = async (
-	deps: StartDeps = defaultStartDeps(),
-): Promise<void> => {
-	try {
-		await startApi(deps);
-	} catch (error) {
-		deps.logger.error(() => ({
-			err: error instanceof Error ? error : new Error(String(error)),
-			msg: "Failed to start API",
-		}));
-		deps.exit(1);
-	}
-};
-
-if (isMain(import.meta.url)) {
-	// Not awaited: a top-level await cannot be emitted in the cjs build, and
-	// main() already handles its own failures rather than rejecting.
-	void main();
-}