@prosopo/client-example-server 2.7.15 → 2.7.17

package/dist/cjs/app.cjs

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("node:path");
+const common = require("@prosopo/common");
+const dotenv = require("@prosopo/dotenv");
+const server = require("@prosopo/server");
+const util = require("@prosopo/util");
+const cors = require("cors");
+const express = require("express");
+const routes = require("./routes/routes.cjs");
+const connection = require("./utils/connection.cjs");
+const database = require("./utils/database.cjs");
+dotenv.loadEnv();
+function getEnvFile(filename = ".env", filepath = "./") {
+  const env = process.env.NODE_ENV || "development";
+  return path.join(filepath, `${filename}.${env}`);
+}
+var ProsopoVerificationType = /* @__PURE__ */ ((ProsopoVerificationType2) => {
+  ProsopoVerificationType2["api"] = "api";
+  ProsopoVerificationType2["local"] = "local";
+  return ProsopoVerificationType2;
+})(ProsopoVerificationType || {});
+const logger = common.getLogger("info", module);
+async function main() {
+  dotenv.loadEnv();
+  const apiPrefix = process.env.NODE_ENV && process.env.NODE_ENV === "production" ? "" : `${process.env.NODE_ENV}-`;
+  const verifyEndpoint = process.env.PROSOPO_VERIFY_ENDPOINT || `https://${apiPrefix}api.prosopo.io/siteverify`;
+  const verifyType = Object.keys(
+    ProsopoVerificationType
+  ).includes(process.env.PROSOPO_VERIFICATION_TYPE) ? process.env.PROSOPO_VERIFICATION_TYPE : "api";
+  const app = express();
+  app.use(cors({ origin: true, credentials: true }));
+  app.use(express.urlencoded({ extended: true }));
+  app.use(express.json());
+  app.use((_, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader(
+      "Access-Control-Allow-Methods",
+      "GET, POST, PUT, PATCH, DELETE"
+    );
+    res.setHeader(
+      "Access-Control-Allow-Headers",
+      "Origin, Content-Type, X-Auth-Token, Authorization"
+    );
+    next();
+  });
+  app.options("/*", (_, res) => {
+    res.sendStatus(200);
+  });
+  const uri = await database.memoryServerSetup();
+  logger.info(() => ({ msg: "mongo uri", data: { uri } }));
+  const mongoose = connection(uri);
+  if (!process.env.PROSOPO_SITE_PRIVATE_KEY) {
+    const mnemonicError = new common.ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", {
+      context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] },
+      logger
+    });
+    logger.error(() => ({ err: mnemonicError }));
+  }
+  const config = server.getServerConfig();
+  logger.info(() => ({ msg: "Config", data: { config } }));
+  app.use(routes(mongoose, config, verifyEndpoint, verifyType));
+  app.listen(
+    config.serverUrl ? Number.parseInt(util.at(config.serverUrl.split(":"), 2)) : 9228
+  );
+}
+main().then(() => {
+  logger.info(() => ({ msg: "Server started" }));
+}).catch((err) => {
+  logger.error(() => ({ err }));
+  process.exit();
+});
+exports.getEnvFile = getEnvFile;

package/dist/cjs/controllers/auth.cjs

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const blake2b = require("@noble/hashes/blake2b");
+const util = require("@polkadot/util");
+const utilCrypto = require("@polkadot/util-crypto");
+const common = require("@prosopo/common");
+const keyring = require("@prosopo/keyring");
+const server = require("@prosopo/server");
+const types = require("@prosopo/types");
+const util$1 = require("@prosopo/util");
+const jwt = require("jsonwebtoken");
+const zod = require("zod");
+const SubscribeBodySpec = types.ProcaptchaResponse.merge(
+  zod.z.object({
+    email: zod.z.string().email(),
+    password: zod.z.string()
+  })
+);
+function hashPassword(password) {
+  return util.u8aToHex(blake2b.blake2b(password));
+}
+const verify = async (prosopoServer, verifyType, verifyEndpoint, token, secret) => {
+  if (verifyType === "api") {
+    console.log("Verifying using the API endpoint", verifyEndpoint);
+    const response = await fetch(verifyEndpoint, {
+      method: "POST",
+      body: JSON.stringify({
+        [types.ApiParams.token]: token,
+        [types.ApiParams.secret]: secret
+      })
+    });
+    const verifiedResponse = await response.json();
+    console.log(verifiedResponse);
+    return verifiedResponse.verified;
+  }
+  const verified = await prosopoServer.isVerified(token);
+  console.log(verified);
+  return verified;
+};
+const signup = async (mongoose, config, verifyEndpoint, verifyType, req, res, next) => {
+  try {
+    const User = mongoose.model("User");
+    const dbUser = await User.findOne({
+      email: { $eq: req.body.email }
+    });
+    const payload = SubscribeBodySpec.parse(req.body);
+    const pair = await keyring.getPair(config.account.secret);
+    const prosopoServer = new server.ProsopoServer(config, pair);
+    if (dbUser) {
+      return res.status(409).json({ message: "email already exists" });
+    }
+    const token = payload[types.ApiParams.procaptchaResponse];
+    if (!config.account.secret) {
+      throw new common.ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", {
+        context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] }
+      });
+    }
+    const verified = await verify(
+      prosopoServer,
+      verifyType,
+      verifyEndpoint,
+      token,
+      config.account.secret
+    );
+    if (verified) {
+      const salt = utilCrypto.randomAsHex(32);
+      const passwordHash = hashPassword(`${req.body.password}${salt}`);
+      if (passwordHash) {
+        return User.create({
+          email: req.body.email,
+          name: req.body.name,
+          password: passwordHash,
+          salt
+        }).then(() => {
+          res.status(200).json({ message: "user created" });
+        }).catch((err) => {
+          console.log(err);
+          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 login = async (mongoose, config, verifyEndpoint, verifyType, req, res) => {
+  const User = mongoose.model("User");
+  const pair = await keyring.getPair(config.account.secret);
+  const prosopoServer = new server.ProsopoServer(config, pair);
+  await User.findOne({
+    email: { $eq: req.body.email }
+  }).then(async (dbUser) => {
+    if (dbUser) {
+      console.log(req.body);
+      const payload = SubscribeBodySpec.parse(req.body);
+      const token = payload[types.ApiParams.procaptchaResponse];
+      if (!config.account.secret) {
+        throw new common.ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", {
+          context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] }
+        });
+      }
+      const verified = await verify(
+        prosopoServer,
+        verifyType,
+        verifyEndpoint,
+        token,
+        config.account.secret
+      );
+      console.log("verified", 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" });
+  });
+};
+const isAuth = (req, res) => {
+  const authHeader = req.get("Authorization") || "";
+  if (!authHeader) {
+    res.status(401).json({ message: "not authenticated" });
+  }
+  const token = util$1.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" });
+  }
+};
+exports.isAuth = isAuth;
+exports.login = login;
+exports.signup = signup;

package/dist/cjs/models/user.cjs

@@ -0,0 +1,23 @@
+"use strict";
+const mongoose = require("mongoose");
+const UserSchema = new mongoose.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
+  }
+});
+module.exports = UserSchema;

package/dist/cjs/routes/routes.cjs

@@ -0,0 +1,23 @@
+"use strict";
+const express = require("express");
+const auth = require("../controllers/auth.cjs");
+const router = express.Router();
+function getRoutes(mongoose, config, verifyEndpoint, verifyType) {
+  router.post(
+    "/login",
+    auth.login.bind(null, mongoose, config, verifyEndpoint, verifyType)
+  );
+  router.post(
+    "/signup",
+    auth.signup.bind(null, mongoose, config, verifyEndpoint, verifyType)
+  );
+  router.get("/private", auth.isAuth);
+  router.get("/public", (req, res) => {
+    res.status(200).json({ message: "here is your public resource" });
+  });
+  router.use("/", (req, res) => {
+    res.status(404).json({ error: "page not found" });
+  });
+  return router;
+}
+module.exports = getRoutes;

package/dist/cjs/utils/connection.cjs

@@ -0,0 +1,15 @@
+"use strict";
+const autoIncrement = require("@typegoose/auto-increment");
+const mongoose = require("mongoose");
+const user = require("../models/user.cjs");
+function connectionFactory(uri) {
+  const conn = mongoose.createConnection(uri);
+  if (!conn.models.user) {
+    user.plugin(autoIncrement.AutoIncrementID, {
+      field: "id"
+    });
+    conn.model("User", user);
+  }
+  return conn;
+}
+module.exports = connectionFactory;

package/dist/cjs/utils/database.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const mongodbMemoryServer = require("mongodb-memory-server");
+async function memoryServerSetup() {
+  const mongod = mongodbMemoryServer.MongoMemoryServer.create();
+  const memoryServer = await mongod;
+  return memoryServer.getUri();
+}
+exports.default = memoryServerSetup;
+exports.memoryServerSetup = memoryServerSetup;

package/dist/controllers/auth.js

@@ -4,150 +4,152 @@ import { randomAsHex } from "@polkadot/util-crypto";
 import { ProsopoEnvError } from "@prosopo/common";
 import { getPair } from "@prosopo/keyring";
 import { ProsopoServer } from "@prosopo/server";
-import { ApiParams, } from "@prosopo/types";
-import { ProcaptchaResponse } from "@prosopo/types";
+import { ProcaptchaResponse, ApiParams } from "@prosopo/types";
 import { at } from "@prosopo/util";
 import jwt from "jsonwebtoken";
 import { z } from "zod";
-const SubscribeBodySpec = ProcaptchaResponse.merge(z.object({
+const SubscribeBodySpec = ProcaptchaResponse.merge(
+  z.object({
     email: z.string().email(),
-    password: z.string(),
-}));
+    password: z.string()
+  })
+);
 function hashPassword(password) {
-    return u8aToHex(blake2b(password));
+  return u8aToHex(blake2b(password));
 }
 const verify = async (prosopoServer, verifyType, verifyEndpoint, token, secret) => {
-    if (verifyType === "api") {
-        console.log("Verifying using the API endpoint", verifyEndpoint);
-        const response = await fetch(verifyEndpoint, {
-            method: "POST",
-            body: JSON.stringify({
-                [ApiParams.token]: token,
-                [ApiParams.secret]: secret,
-            }),
-        });
-        const verifiedResponse = await response.json();
-        console.log(verifiedResponse);
-        return verifiedResponse.verified;
-    }
-    const verified = await prosopoServer.isVerified(token);
-    console.log(verified);
-    return verified;
+  if (verifyType === "api") {
+    console.log("Verifying using the API endpoint", verifyEndpoint);
+    const response = await fetch(verifyEndpoint, {
+      method: "POST",
+      body: JSON.stringify({
+        [ApiParams.token]: token,
+        [ApiParams.secret]: secret
+      })
+    });
+    const verifiedResponse = await response.json();
+    console.log(verifiedResponse);
+    return verifiedResponse.verified;
+  }
+  const verified = await prosopoServer.isVerified(token);
+  console.log(verified);
+  return verified;
 };
 const signup = async (mongoose, config, verifyEndpoint, verifyType, req, res, next) => {
-    try {
-        const User = mongoose.model("User");
-        const dbUser = await User.findOne({
-            email: { $eq: req.body.email },
-        });
-        const payload = SubscribeBodySpec.parse(req.body);
-        const pair = await getPair(config.account.secret);
-        const prosopoServer = new ProsopoServer(config, pair);
-        if (dbUser) {
-            return res.status(409).json({ message: "email already exists" });
-        }
-        const token = payload[ApiParams.procaptchaResponse];
-        if (!config.account.secret) {
-            throw new ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", {
-                context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] },
-            });
-        }
-        const verified = await verify(prosopoServer, verifyType, verifyEndpoint, token, config.account.secret);
-        if (verified) {
-            const salt = randomAsHex(32);
-            const passwordHash = hashPassword(`${req.body.password}${salt}`);
-            if (passwordHash) {
-                return User.create({
-                    email: req.body.email,
-                    name: req.body.name,
-                    password: passwordHash,
-                    salt: salt,
-                })
-                    .then(() => {
-                    res.status(200).json({ message: "user created" });
-                })
-                    .catch((err) => {
-                    console.log(err);
-                    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 login = async (mongoose, config, verifyEndpoint, verifyType, req, res) => {
+  try {
     const User = mongoose.model("User");
+    const dbUser = await User.findOne({
+      email: { $eq: req.body.email }
+    });
+    const payload = SubscribeBodySpec.parse(req.body);
     const pair = await getPair(config.account.secret);
     const prosopoServer = new ProsopoServer(config, pair);
-    await User.findOne({
-        email: { $eq: req.body.email },
-    })
-        .then(async (dbUser) => {
-        if (dbUser) {
-            console.log(req.body);
-            const payload = SubscribeBodySpec.parse(req.body);
-            const token = payload[ApiParams.procaptchaResponse];
-            if (!config.account.secret) {
-                throw new ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", {
-                    context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] },
-                });
-            }
-            const verified = await verify(prosopoServer, verifyType, verifyEndpoint, token, config.account.secret);
-            console.log("verified", verified);
-            if (verified) {
-                const passwordHash = hashPassword(`${req.body.password}${dbUser.salt}`);
-                if (passwordHash !== 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: 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" });
-    });
-};
-const isAuth = (req, res) => {
-    const authHeader = req.get("Authorization") || "";
-    if (!authHeader) {
-        res.status(401).json({ message: "not authenticated" });
+    if (dbUser) {
+      return res.status(409).json({ message: "email already exists" });
     }
-    const token = at(authHeader.split(" "), 1);
-    let decodedToken = "";
-    try {
-        decodedToken = jwt.verify(token, "secret");
+    const token = payload[ApiParams.procaptchaResponse];
+    if (!config.account.secret) {
+      throw new ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", {
+        context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] }
+      });
     }
-    catch (err) {
-        res.status(500).json({
-            message: err.message || "could not decode the token",
+    const verified = await verify(
+      prosopoServer,
+      verifyType,
+      verifyEndpoint,
+      token,
+      config.account.secret
+    );
+    if (verified) {
+      const salt = randomAsHex(32);
+      const passwordHash = hashPassword(`${req.body.password}${salt}`);
+      if (passwordHash) {
+        return User.create({
+          email: req.body.email,
+          name: req.body.name,
+          password: passwordHash,
+          salt
+        }).then(() => {
+          res.status(200).json({ message: "user created" });
+        }).catch((err) => {
+          console.log(err);
+          res.status(502).json({ message: "error while creating the user" });
         });
+      }
+    } else {
+      res.status(401).json({ message: "user has not completed a captcha", verified });
     }
-    if (!decodedToken) {
-        res.status(401).json({ message: "unauthorized" });
-    }
-    else {
-        res.status(200).json({ message: "here is your resource" });
+  } catch (err) {
+    console.error("error", err);
+    res.status(500).json({ message: err.message || "internal server error" });
+  }
+};
+const login = async (mongoose, config, verifyEndpoint, verifyType, req, res) => {
+  const User = mongoose.model("User");
+  const pair = await getPair(config.account.secret);
+  const prosopoServer = new ProsopoServer(config, pair);
+  await User.findOne({
+    email: { $eq: req.body.email }
+  }).then(async (dbUser) => {
+    if (dbUser) {
+      console.log(req.body);
+      const payload = SubscribeBodySpec.parse(req.body);
+      const token = payload[ApiParams.procaptchaResponse];
+      if (!config.account.secret) {
+        throw new ProsopoEnvError("GENERAL.MNEMONIC_UNDEFINED", {
+          context: { missingParams: ["PROSOPO_SITE_PRIVATE_KEY"] }
+        });
+      }
+      const verified = await verify(
+        prosopoServer,
+        verifyType,
+        verifyEndpoint,
+        token,
+        config.account.secret
+      );
+      console.log("verified", 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" });
+  });
+};
+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" });
+  }
+};
+export {
+  isAuth,
+  login,
+  signup
 };
-export { signup, login, isAuth };
-//# sourceMappingURL=auth.js.map

package/dist/models/user.js

@@ -1,23 +1,24 @@
 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,
-    },
+  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 default UserSchema;
-//# sourceMappingURL=user.js.map
+export {
+  UserSchema as default
+};

package/dist/routes/routes.js

@@ -1,17 +1,24 @@
 import express from "express";
-import { isAuth, login, signup } from "../controllers/auth.js";
+import { login, signup, isAuth } from "../controllers/auth.js";
 const 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.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.use("/", (req, res) => {
+    res.status(404).json({ error: "page not found" });
+  });
+  return router;
 }
-export default getRoutes;
-//# sourceMappingURL=routes.js.map
+export {
+  getRoutes as default
+};