@prosopo/client-example-server 2.7.122 → 2.7.123

package/dist/controllers/auth.js

@@ -1,255 +1,185 @@
-import { blake2b } from "@noble/hashes/blake2b";
-import { u8aToHex } from "@polkadot/util";
-import { randomAsHex } from "@polkadot/util-crypto";
 import { ProsopoEnvError } from "@prosopo/common";
-import { getPair } from "@prosopo/keyring";
 import { getLogger } from "@prosopo/logger";
 import { ProsopoServer } from "@prosopo/server";
-import { ProcaptchaResponse, CaptchaType, ApiParams } from "@prosopo/types";
 import { at } from "@prosopo/util";
+import { blake2b } from "@noble/hashes/blake2b";
+import { u8aToHex } from "@polkadot/util";
+import { randomAsHex } from "@polkadot/util-crypto";
+import { getPair } from "@prosopo/keyring";
+import { ApiParams, CaptchaType, ProcaptchaResponse } from "@prosopo/types";
 import jwt from "jsonwebtoken";
 import { z } from "zod";
-const logger = getLogger("info", "client-example-server:auth");
-const SubscribeBodySpec = ProcaptchaResponse.merge(
-  z.object({
-    email: z.string().email(),
-    password: z.string(),
-    siteKey: z.string()
-  })
-);
+//#region src/controllers/auth.ts
+var logger = getLogger("info", "client-example-server:auth");
+var SubscribeBodySpec = ProcaptchaResponse.merge(z.object({
+	email: z.string().email(),
+	password: z.string(),
+	siteKey: z.string()
+}));
 function hashPassword(password) {
-  return u8aToHex(blake2b(password));
+	return u8aToHex(blake2b(password));
 }
-const NO_IP = "NO_IP";
-const getPairAndSecretForSiteKey = (baseSecret, siteKey) => {
-  let pair;
-  let secret = baseSecret;
-  pair = getPair(secret);
-  if (pair.address === siteKey) {
-    logger.info(() => ({
-      msg: "Site key matches the server configuration without captcha type suffix",
-      data: {
-        siteKeyDerived: pair?.address,
-        siteKey
-      }
-    }));
-    return { pair, secret };
-  }
-  for (const captchaType of [
-    CaptchaType.pow,
-    CaptchaType.image,
-    CaptchaType.frictionless,
-    CaptchaType.puzzle
-  ]) {
-    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: {
-        captchaType,
-        siteKeyDerived: pair?.address,
-        siteKey
-      }
-    }));
-    if (pair.address === siteKey) {
-      console.log(`[PAIR CHECK] ✅ Match found for ${captchaType}!`);
-      secret = newSecret;
-      break;
-    }
-  }
-  if (!pair || pair.address !== siteKey) {
-    throw new Error(
-      `Site key does not match the server configuration: Provided ${siteKey} vs Server ${pair?.address}`
-    );
-  }
-  return { pair, secret };
-};
-const getResponse = async (ip, token, secret, verifyEndpoint, email) => {
-  const body = {
-    [ApiParams.token]: token,
-    [ApiParams.secret]: secret,
-    ...email ? { [ApiParams.email]: email } : {}
-  };
-  if (process.env.NODE_ENV !== "development") {
-    body[ApiParams.ip] = ip;
-  }
-  logger.info(() => ({
-    data: {
-      body
-    }
-  }));
-  const response = await fetch(verifyEndpoint, {
-    method: "POST",
-    body: JSON.stringify(body)
-  });
-  return response.json();
+var NO_IP = "NO_IP";
+/**
+* Derives the correct KeyringPair and secret for a given site key by trying different captcha types.
+* @param baseSecret - The base secret from config
+* @param siteKey - The site key to match against
+* @returns Object containing the matched pair and its corresponding secret
+* @throws Error if no matching pair is found
+*/
+var getPairAndSecretForSiteKey = (baseSecret, siteKey) => {
+	let pair;
+	let secret = baseSecret;
+	pair = getPair(secret);
+	if (pair.address === siteKey) {
+		logger.info(() => ({
+			msg: "Site key matches the server configuration without captcha type suffix",
+			data: {
+				siteKeyDerived: pair?.address,
+				siteKey
+			}
+		}));
+		return {
+			pair,
+			secret
+		};
+	}
+	for (const captchaType of [
+		CaptchaType.pow,
+		CaptchaType.image,
+		CaptchaType.frictionless,
+		CaptchaType.puzzle
+	]) {
+		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: {
+				captchaType,
+				siteKeyDerived: pair?.address,
+				siteKey
+			}
+		}));
+		if (pair.address === siteKey) {
+			console.log(`[PAIR CHECK] ✅ Match found for ${captchaType}!`);
+			secret = newSecret;
+			break;
+		}
+	}
+	if (!pair || pair.address !== siteKey) throw new Error(`Site key does not match the server configuration: Provided ${siteKey} vs Server ${pair?.address}`);
+	return {
+		pair,
+		secret
+	};
 };
-const verify = async (prosopoServer, verifyType, verifyEndpoint, token, secret, ip, email) => {
-  if (verifyType === "api") {
-    logger.info(() => ({
-      msg: "Verifying using the API endpoint",
-      data: {
-        verifyEndpoint
-      }
-    }));
-    const response = await getResponse(
-      ip,
-      token,
-      secret,
-      verifyEndpoint,
-      email
-    );
-    logger.info(() => ({
-      data: {
-        response
-      }
-    }));
-    return response.verified;
-  }
-  const verified = await prosopoServer.isVerified(token, ip, email);
-  logger.info(() => ({
-    data: {
-      verified
-    }
-  }));
-  return verified[ApiParams.verified];
+var getResponse = async (ip, token, secret, verifyEndpoint, email) => {
+	const body = {
+		[ApiParams.token]: token,
+		[ApiParams.secret]: secret,
+		...email ? { [ApiParams.email]: email } : {}
+	};
+	if (process.env.NODE_ENV !== "development") body[ApiParams.ip] = ip;
+	logger.info(() => ({ data: { body } }));
+	return (await fetch(verifyEndpoint, {
+		method: "POST",
+		body: JSON.stringify(body)
+	})).json();
 };
-const signup = async (mongoose, config, verifyEndpoint, verifyType, req, res, next) => {
-  try {
-    if (!config.account.secret) {
-      throw new ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", {
-        context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] }
-      });
-    }
-    const User = mongoose.model("User");
-    const dbUser = await User.findOne({
-      email: { $eq: req.body.email }
-    });
-    const payload = SubscribeBodySpec.parse(req.body);
-    const token = payload[ApiParams.procaptchaResponse];
-    const siteKey = payload[ApiParams.siteKey];
-    const { pair, secret } = getPairAndSecretForSiteKey(
-      config.account.secret,
-      siteKey
-    );
-    const prosopoServer = new ProsopoServer(config, pair);
-    if (dbUser) {
-      return res.status(409).json({ message: "email already exists" });
-    }
-    const email = req.body.email;
-    const verified = await verify(
-      prosopoServer,
-      verifyType,
-      verifyEndpoint,
-      token,
-      secret,
-      req.headers["x-client-ip"]?.toString() || "127.0.0.1",
-      email
-    );
-    if (verified === true) {
-      const salt = randomAsHex(32);
-      const passwordHash = hashPassword(`${req.body.password}${salt}`);
-      if (passwordHash) {
-        return User.create({
-          email,
-          name: req.body.name,
-          password: passwordHash,
-          salt
-        }).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) {
-    console.error("error", err);
-    res.status(500).json({ message: err.message || "internal server error" });
-  }
+var verify = async (prosopoServer, verifyType, verifyEndpoint, token, secret, ip, email) => {
+	if (verifyType === "api") {
+		logger.info(() => ({
+			msg: "Verifying using the API endpoint",
+			data: { verifyEndpoint }
+		}));
+		const response = await getResponse(ip, token, secret, verifyEndpoint, email);
+		logger.info(() => ({ data: { response } }));
+		return response.verified;
+	}
+	const verified = await prosopoServer.isVerified(token, ip, email);
+	logger.info(() => ({ data: { verified } }));
+	return verified[ApiParams.verified];
 };
-const login = async (mongoose, config, verifyEndpoint, verifyType, req, res) => {
-  const User = mongoose.model("User");
-  await User.findOne({
-    email: { $eq: req.body.email }
-  }).then(async (dbUser) => {
-    if (dbUser) {
-      const payload = SubscribeBodySpec.parse(req.body);
-      const token = payload[ApiParams.procaptchaResponse];
-      const siteKey = payload[ApiParams.siteKey];
-      if (!config.account.secret) {
-        throw new ProsopoEnvError("GENERAL.SECRET_MISSING", {
-          context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] }
-        });
-      }
-      const { pair, secret } = getPairAndSecretForSiteKey(
-        config.account.secret,
-        siteKey
-      );
-      const prosopoServer = new ProsopoServer(config, pair);
-      const verified = await verify(
-        prosopoServer,
-        verifyType,
-        verifyEndpoint,
-        token,
-        secret,
-        req.headers["x-client-ip"]?.toString() || NO_IP
-      );
-      logger.info(() => ({
-        data: {
-          verified
-        }
-      }));
-      if (verified) {
-        const passwordHash = hashPassword(
-          `${req.body.password}${dbUser.salt}`
-        );
-        if (passwordHash !== dbUser.password) {
-          return res.status(401).json({ message: "invalid credentials" });
-        }
-        const token2 = jwt.sign({ email: req.body.email }, "secret", {
-          expiresIn: "1h"
-        });
-        return res.status(200).json({ message: "user logged in", token: token2 });
-      }
-      return res.status(401).json({ message: "user has not completed a captcha", verified });
-    }
-    return res.status(404).json({ message: "user not found" });
-  }).catch((err) => {
-    console.error("error", err);
-    res.status(500).json({ message: err.message || "internal server error" });
-  });
+var signup = async (mongoose, config, verifyEndpoint, verifyType, req, res, next) => {
+	try {
+		if (!config.account.secret) throw new ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", { context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] } });
+		const User = mongoose.model("User");
+		const dbUser = await User.findOne({ email: { $eq: req.body.email } });
+		const payload = SubscribeBodySpec.parse(req.body);
+		const token = payload[ApiParams.procaptchaResponse];
+		const siteKey = payload[ApiParams.siteKey];
+		const { pair, secret } = getPairAndSecretForSiteKey(config.account.secret, siteKey);
+		const prosopoServer = new ProsopoServer(config, pair);
+		if (dbUser) return res.status(409).json({ message: "email already exists" });
+		const email = req.body.email;
+		const verified = await verify(prosopoServer, verifyType, verifyEndpoint, token, secret, req.headers["x-client-ip"]?.toString() || "127.0.0.1", email);
+		if (verified === true) {
+			const salt = randomAsHex(32);
+			const passwordHash = hashPassword(`${req.body.password}${salt}`);
+			if (passwordHash) return User.create({
+				email,
+				name: req.body.name,
+				password: passwordHash,
+				salt
+			}).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) {
+		console.error("error", err);
+		res.status(500).json({ message: err.message || "internal server error" });
+	}
 };
-const isAuth = (req, res) => {
-  const authHeader = req.get("Authorization") || "";
-  if (!authHeader) {
-    res.status(401).json({ message: "not authenticated" });
-  }
-  const token = at(authHeader.split(" "), 1);
-  let decodedToken = "";
-  try {
-    decodedToken = jwt.verify(token, "secret");
-  } catch (err) {
-    res.status(500).json({
-      message: err.message || "could not decode the token"
-    });
-  }
-  if (!decodedToken) {
-    res.status(401).json({ message: "unauthorized" });
-  } else {
-    res.status(200).json({ message: "here is your resource" });
-  }
+var login = async (mongoose, config, verifyEndpoint, verifyType, req, res) => {
+	await mongoose.model("User").findOne({ email: { $eq: req.body.email } }).then(async (dbUser) => {
+		if (dbUser) {
+			const payload = SubscribeBodySpec.parse(req.body);
+			const token = payload[ApiParams.procaptchaResponse];
+			const siteKey = payload[ApiParams.siteKey];
+			if (!config.account.secret) throw new ProsopoEnvError("GENERAL.SECRET_MISSING", { context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] } });
+			const { pair, secret } = getPairAndSecretForSiteKey(config.account.secret, siteKey);
+			const verified = await verify(new ProsopoServer(config, pair), verifyType, verifyEndpoint, token, secret, req.headers["x-client-ip"]?.toString() || NO_IP);
+			logger.info(() => ({ data: { verified } }));
+			if (verified) {
+				if (hashPassword(`${req.body.password}${dbUser.salt}`) !== dbUser.password) return res.status(401).json({ message: "invalid credentials" });
+				const token = jwt.sign({ email: req.body.email }, "secret", { expiresIn: "1h" });
+				return res.status(200).json({
+					message: "user logged in",
+					token
+				});
+			}
+			return res.status(401).json({
+				message: "user has not completed a captcha",
+				verified
+			});
+		}
+		return res.status(404).json({ message: "user not found" });
+	}).catch((err) => {
+		console.error("error", err);
+		res.status(500).json({ message: err.message || "internal server error" });
+	});
 };
-export {
-  isAuth,
-  login,
-  signup
+var isAuth = (req, res) => {
+	const authHeader = req.get("Authorization") || "";
+	if (!authHeader) res.status(401).json({ message: "not authenticated" });
+	const token = at(authHeader.split(" "), 1);
+	let decodedToken = "";
+	try {
+		decodedToken = jwt.verify(token, "secret");
+	} catch (err) {
+		res.status(500).json({ message: err.message || "could not decode the token" });
+	}
+	if (!decodedToken) res.status(401).json({ message: "unauthorized" });
+	else res.status(200).json({ message: "here is your resource" });
 };
+//#endregion
+export { isAuth, login, signup };

package/dist/models/user.d.ts

@@ -6,11 +6,11 @@ export interface UserInterface {
     password: string;
     salt: string;
 }
-declare const UserSchema: mongoose.Schema<UserInterface, mongoose.Model<UserInterface, any, any, any, mongoose.Document<unknown, any, UserInterface> & UserInterface & {
+declare const UserSchema: mongoose.Schema<UserInterface, mongoose.Model<UserInterface, any, any, any, mongoose.Document<unknown, any, UserInterface, any, {}> & UserInterface & {
     _id: mongoose.Types.ObjectId;
 } & {
     __v: number;
-}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, UserInterface, mongoose.Document<unknown, {}, mongoose.FlatRecord<UserInterface>> & mongoose.FlatRecord<UserInterface> & {
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, UserInterface, mongoose.Document<unknown, {}, mongoose.FlatRecord<UserInterface>, {}, mongoose.DefaultSchemaOptions> & mongoose.FlatRecord<UserInterface> & {
     _id: mongoose.Types.ObjectId;
 } & {
     __v: number;

package/dist/models/user.js

@@ -1,24 +1,20 @@
 import mongoose, { Schema } from "mongoose";
-const UserSchema = new Schema({
-  email: {
-    type: mongoose.SchemaTypes.String,
-    required: true
-  },
-  name: {
-    type: mongoose.SchemaTypes.String
-  },
-  password: {
-    type: mongoose.SchemaTypes.String,
-    required: true
-  },
-  id: {
-    type: mongoose.SchemaTypes.Number
-  },
-  salt: {
-    type: mongoose.SchemaTypes.String,
-    required: true
-  }
+//#region src/models/user.ts
+var UserSchema = new Schema({
+	email: {
+		type: mongoose.SchemaTypes.String,
+		required: true
+	},
+	name: { type: mongoose.SchemaTypes.String },
+	password: {
+		type: mongoose.SchemaTypes.String,
+		required: true
+	},
+	id: { type: mongoose.SchemaTypes.Number },
+	salt: {
+		type: mongoose.SchemaTypes.String,
+		required: true
+	}
 });
-export {
-  UserSchema as default
-};
+//#endregion
+export { UserSchema as default };

package/dist/routes/routes.js

@@ -1,27 +1,21 @@
+import { isAuth, login, signup } from "../controllers/auth.js";
 import express from "express";
-import { login, signup, isAuth } from "../controllers/auth.js";
-const router = express.Router();
+//#region src/routes/routes.ts
+var router = express.Router();
 function getRoutes(mongoose, config, verifyEndpoint, verifyType) {
-  router.post(
-    "/login",
-    login.bind(null, mongoose, config, verifyEndpoint, verifyType)
-  );
-  router.post(
-    "/signup",
-    signup.bind(null, mongoose, config, verifyEndpoint, verifyType)
-  );
-  router.get("/private", isAuth);
-  router.get("/public", (req, res) => {
-    res.status(200).json({ message: "here is your public resource" });
-  });
-  router.get("/health", (req, res) => {
-    res.status(200).json({ status: "ok" });
-  });
-  router.use("/", (req, res) => {
-    res.status(404).json({ error: "page not found" });
-  });
-  return router;
+	router.post("/login", login.bind(null, mongoose, config, verifyEndpoint, verifyType));
+	router.post("/signup", signup.bind(null, mongoose, config, verifyEndpoint, verifyType));
+	router.get("/private", isAuth);
+	router.get("/public", (req, res) => {
+		res.status(200).json({ message: "here is your public resource" });
+	});
+	router.get("/health", (req, res) => {
+		res.status(200).json({ status: "ok" });
+	});
+	router.use("/", (req, res) => {
+		res.status(404).json({ error: "page not found" });
+	});
+	return router;
 }
-export {
-  getRoutes as default
-};
+//#endregion
+export { getRoutes as default };

package/dist/utils/connection.js

@@ -1,25 +1,20 @@
+import UserSchema from "../models/user.js";
 import { fileURLToPath } from "node:url";
 import { getMongoConnectionOptions } from "@prosopo/database";
 import { AutoIncrementID } from "@typegoose/auto-increment";
 import mongoose from "mongoose";
-import UserSchema from "../models/user.js";
+//#region src/utils/connection.ts
 function connectionFactory(uri) {
-  const appName = fileURLToPath(import.meta.url);
-  const conn = mongoose.createConnection(
-    uri,
-    getMongoConnectionOptions({
-      url: uri,
-      appName
-    })
-  );
-  if (!conn.models.user) {
-    UserSchema.plugin(AutoIncrementID, {
-      field: "id"
-    });
-    conn.model("User", UserSchema);
-  }
-  return conn;
+	const appName = fileURLToPath(import.meta.url);
+	const conn = mongoose.createConnection(uri, getMongoConnectionOptions({
+		url: uri,
+		appName
+	}));
+	if (!conn.models.user) {
+		UserSchema.plugin(AutoIncrementID, { field: "id" });
+		conn.model("User", UserSchema);
+	}
+	return conn;
 }
-export {
-  connectionFactory as default
-};
+//#endregion
+export { connectionFactory as default };

package/dist/utils/database.js

@@ -1,10 +1,6 @@
+//#region src/utils/database.ts
 async function memoryServerSetup() {
-  const MongoMemoryServer = (await import("mongodb-memory-server")).MongoMemoryServer;
-  const mongod = MongoMemoryServer.create();
-  const memoryServer = await mongod;
-  return memoryServer.getUri();
+	return (await (await import("mongodb-memory-server")).MongoMemoryServer.create()).getUri();
 }
-export {
-  memoryServerSetup as default,
-  memoryServerSetup
-};
+//#endregion
+export { memoryServerSetup as default, memoryServerSetup };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prosopo/client-example-server",
-	"version": "2.7.122",
+	"version": "2.7.123",
 	"description": "Backend for client-example",
 	"main": "dist/app.js",
 	"types": "dist/app.d.ts",
@@ -42,34 +42,34 @@
 		"@noble/hashes": "1.8.0",
 		"@polkadot/util": "13.5.7",
 		"@polkadot/util-crypto": "13.5.7",
-		"@prosopo/common": "3.1.47",
-		"@prosopo/database": "3.15.19",
-		"@prosopo/logger": "2.0.3",
-		"@prosopo/dotenv": "3.0.49",
-		"@prosopo/keyring": "2.9.60",
-		"@prosopo/server": "2.10.40",
-		"@prosopo/types": "4.9.12",
-		"@prosopo/util": "3.3.4",
+		"@prosopo/common": "3.1.48",
+		"@prosopo/database": "3.15.20",
+		"@prosopo/logger": "2.0.4",
+		"@prosopo/dotenv": "3.0.50",
+		"@prosopo/keyring": "2.9.61",
+		"@prosopo/server": "2.10.41",
+		"@prosopo/types": "4.10.0",
+		"@prosopo/util": "3.3.5",
 		"@typegoose/auto-increment": "4.13.0",
 		"cors": "2.8.5",
 		"express": "4.21.2",
 		"jsonwebtoken": "9.0.2",
 		"mongodb-memory-server": "10.3.0",
-		"mongoose": "8.13.0",
+		"mongoose": "8.24.1",
 		"zod": "3.23.8"
 	},
 	"devDependencies": {
-		"@prosopo/config": "3.3.4",
+		"@prosopo/config": "3.3.5",
 		"@types/jsonwebtoken": "9.0.6",
 		"@types/node": "22.10.2",
-		"@vitest/coverage-v8": "3.2.4",
+		"@vitest/coverage-v8": "4.1.10",
 		"concurrently": "9.0.1",
 		"del-cli": "6.0.0",
 		"npm-run-all": "4.1.5",
 		"tslib": "2.7.0",
 		"tsx": "4.20.3",
 		"typescript": "5.6.2",
-		"vite": "6.4.1",
-		"vitest": "3.2.4"
+		"vite": "8.1.5",
+		"vitest": "4.1.10"
 	}
 }