format project

src/routes/apiRoutes.js

@@ -11,138 +11,130 @@ const rejectIfNotAuthorizedMiddleware = require('../middlewares/rejectIfNotAutho
 const router = express.Router();
 
 router.get('/signup/nostr-challenge', async (req, res) => {
-    const inviteUuid = req.cookies.inviteUuid;
+  const inviteUuid = req.cookies.inviteUuid;
 
-    let signUpChallenge;
-    try {
-        signUpChallenge = await invitesService.createSignUpChallenge(
-            inviteUuid
-        )
-    } catch (error) {
-        if (error instanceof errors.NotFoundError) {
-            return res.status(404).json({
-                success: false,
-                message: 'Could not find invite with that id.'
-            })
-        }
-
-        if (error instanceof errors.AlreadyUsedError) {
-            return res.status(410).json({
-                success: false,
-                message: 'That invite has already been used.'
-            })
-        }
-
-        return res.status(500).json({
-            success: false,
-            message: 'Unexpected error.'
-        })
+  let signUpChallenge;
+  try {
+    signUpChallenge = await invitesService.createSignUpChallenge(inviteUuid);
+  } catch (error) {
+    if (error instanceof errors.NotFoundError) {
+      return res.status(404).json({
+        success: false,
+        message: 'Could not find invite with that id.',
+      });
     }
 
-    let relatedNostrChallenge;
-    try {
-        relatedNostrChallenge = await nostrService.getNostrChallenge(
-            signUpChallenge.nostr_challenge_uuid
-        )
-    } catch (error) {
-        return res.status(500).json({
-            success: false,
-            message: 'Unexpected error.'
-        })
+    if (error instanceof errors.AlreadyUsedError) {
+      return res.status(410).json({
+        success: false,
+        message: 'That invite has already been used.',
+      });
     }
 
-    return res.status(200).json({ 'challenge': relatedNostrChallenge.challenge });
+    return res.status(500).json({
+      success: false,
+      message: 'Unexpected error.',
+    });
+  }
+
+  let relatedNostrChallenge;
+  try {
+    relatedNostrChallenge = await nostrService.getNostrChallenge(
+      signUpChallenge.nostr_challenge_uuid
+    );
+  } catch (error) {
+    return res.status(500).json({
+      success: false,
+      message: 'Unexpected error.',
+    });
+  }
+
+  return res.status(200).json({ challenge: relatedNostrChallenge.challenge });
 });
 
+router.post('/signup/nostr-verify', async (req, res) => {
+  const signedEvent = req.body;
+  const sessionUuid = req.cookies.sessionUuid;
 
-router.post("/signup/nostr-verify", async (req, res) => {
-    const signedEvent = req.body;
-    const sessionUuid = req.cookies.sessionUuid;
-
-    let completedSignUpChallenge;
-    try {
-        completedSignUpChallenge = await invitesService.verifySignUpChallenge(signedEvent);
-    } catch (error) {
-        if (error instanceof errors.ExpiredError) {
-            return res.status(410).json({
-                success: false,
-                message: 'The challenge has expired, request a new one.'
-            })
-        }
-        if (error instanceof errors.AlreadyUsedError) {
-            return res.status(410).json({
-                success: false,
-                message: 'The challenge has been used, request a new one.'
-            })
-        }
-        if (error instanceof errors.InvalidSignatureError) {
-            return res.status(400).json({
-                success: false,
-                message: 'The challenge signature is not valid.'
-            })
-        }
+  let completedSignUpChallenge;
+  try {
+    completedSignUpChallenge =
+      await invitesService.verifySignUpChallenge(signedEvent);
+  } catch (error) {
+    if (error instanceof errors.ExpiredError) {
+      return res.status(410).json({
+        success: false,
+        message: 'The challenge has expired, request a new one.',
+      });
     }
+    if (error instanceof errors.AlreadyUsedError) {
+      return res.status(410).json({
+        success: false,
+        message: 'The challenge has been used, request a new one.',
+      });
+    }
+    if (error instanceof errors.InvalidSignatureError) {
+      return res.status(400).json({
+        success: false,
+        message: 'The challenge signature is not valid.',
+      });
+    }
+  }
 
-    await sessionService.relateSessionToPublicKey(
-        sessionUuid,
-        completedSignUpChallenge.public_key
-    )
+  await sessionService.relateSessionToPublicKey(
+    sessionUuid,
+    completedSignUpChallenge.public_key
+  );
 
-    return res.status(200).json({ success: true });
+  return res.status(200).json({ success: true });
 });
 
 router.post(
-    "/set-contact-details",
-    rejectIfNotAuthorizedMiddleware,
-    attachPublicKeyMiddleware,
-    async (req, res) => {
-        const encryptedContactDetails = req.body.encryptedContactDetails;
-        const publicKey = req.cookies.publicKey;
+  '/set-contact-details',
+  rejectIfNotAuthorizedMiddleware,
+  attachPublicKeyMiddleware,
+  async (req, res) => {
+    const encryptedContactDetails = req.body.encryptedContactDetails;
+    const publicKey = req.cookies.publicKey;
 
-        if (!encryptedContactDetails) {
-            return res.status(400).json({
-                success: false,
-                message: 'Missing contact details.'
-            })
-        }
-
-        await profileService.setContactDetails(
-            publicKey,
-            encryptedContactDetails
-        )
-
-        return res.status(200).json({
-            success: true,
-            message: 'Contact details set successfully.'
-        })
+    if (!encryptedContactDetails) {
+      return res.status(400).json({
+        success: false,
+        message: 'Missing contact details.',
+      });
     }
+
+    await profileService.setContactDetails(publicKey, encryptedContactDetails);
+
+    return res.status(200).json({
+      success: true,
+      message: 'Contact details set successfully.',
+    });
+  }
 );
 
 router.post(
-    "/set-nym",
-    rejectIfNotAuthorizedMiddleware,
-    attachPublicKeyMiddleware,
-    async (req, res) => {
-        const nym = req.body.nym;
-        const publicKey = req.cookies.publicKey;
+  '/set-nym',
+  rejectIfNotAuthorizedMiddleware,
+  attachPublicKeyMiddleware,
+  async (req, res) => {
+    const nym = req.body.nym;
+    const publicKey = req.cookies.publicKey;
 
-        if (!nym) {
-            return res.status(400).json({
-                success: false,
-                message: 'Missing nym'
-            })
-        }
-
-        await profileService.setNym(
-            publicKey,
-            nym
-        )
-
-        return res.status(200).json({
-            success: true,
-            message: 'Nym set successfully.'
-        })
+    if (!nym) {
+      return res.status(400).json({
+        success: false,
+        message: 'Missing nym',
+      });
     }
+
+    await profileService.setNym(publicKey, nym);
+
+    return res.status(200).json({
+      success: true,
+      message: 'Nym set successfully.',
+    });
+  }
 );
 
 module.exports = router;

src/routes/webRoutes.js

@@ -2,66 +2,68 @@ const express = require('express');
 const router = express.Router();
 
 const redirectIfNotAuthorizedMiddleware = require('../middlewares/redirectIfNotAuthorizedMiddleware');
-const invitesService = require('../services/invitesService')
+const invitesService = require('../services/invitesService');
 
 router.get('/', (req, res) => {
-    res.render('index', { uuid: req.cookies.sessionUuid });
+  res.render('index', { uuid: req.cookies.sessionUuid });
 });
 
 router.get('/invite/:inviteUuid', async (req, res) => {
-    const { inviteUuid } = req.params;
+  const { inviteUuid } = req.params;
 
-    res.cookie('inviteUuid', inviteUuid, { httpOnly: true, maxAge: 86400000 });
+  res.cookie('inviteUuid', inviteUuid, { httpOnly: true, maxAge: 86400000 });
 
-    let invite;
-    try {
-        invite = await invitesService.getAppInvite(inviteUuid);
-        if (!invite) {
-            return res.status(404).render('error', { message: 'Invite not found.' });
-        }
-
-        if (await invitesService.isAppInviteSpent(inviteUuid)) {
-            return res.status(410).render('invite_spent', { invite })
-        }
-
-    } catch (error) {
-        console.error('Error fetching invite:', error);
-        return res.status(500).render('error', { message: 'An error occurred' });
+  let invite;
+  try {
+    invite = await invitesService.getAppInvite(inviteUuid);
+    if (!invite) {
+      return res.status(404).render('error', { message: 'Invite not found.' });
     }
 
-    return res.render('invite', { invite });
+    if (await invitesService.isAppInviteSpent(inviteUuid)) {
+      return res.status(410).render('invite_spent', { invite });
+    }
+  } catch (error) {
+    console.error('Error fetching invite:', error);
+    return res.status(500).render('error', { message: 'An error occurred' });
+  }
+
+  return res.render('invite', { invite });
 });
 
 router.get('/invite/:inviteUuid', async (req, res) => {
-    const { inviteUuid } = req.params;
+  const { inviteUuid } = req.params;
 
-    res.cookie('inviteUuid', inviteUuid, { httpOnly: true, maxAge: 86400000 });
+  res.cookie('inviteUuid', inviteUuid, { httpOnly: true, maxAge: 86400000 });
 
-    let invite;
-    try {
-        invite = await invitesService.getAppInvite(inviteUuid);
-        if (!invite) {
-            return res.status(404).render('error', { message: 'Invite not found.' });
-        }
-
-        if (await invitesService.isAppInviteSpent(inviteUuid)) {
-            return res.status(410).render('invite_spent', { invite })
-        }
-
-    } catch (error) {
-        console.error('Error fetching invite:', error);
-        return res.status(500).render('error', { message: 'An error occurred' });
+  let invite;
+  try {
+    invite = await invitesService.getAppInvite(inviteUuid);
+    if (!invite) {
+      return res.status(404).render('error', { message: 'Invite not found.' });
     }
 
-    return res.render('invite', { invite });
+    if (await invitesService.isAppInviteSpent(inviteUuid)) {
+      return res.status(410).render('invite_spent', { invite });
+    }
+  } catch (error) {
+    console.error('Error fetching invite:', error);
+    return res.status(500).render('error', { message: 'An error occurred' });
+  }
+
+  return res.render('invite', { invite });
 });
 
-router.get('/createProfile', redirectIfNotAuthorizedMiddleware, async (req, res) => {
+router.get(
+  '/createProfile',
+  redirectIfNotAuthorizedMiddleware,
+  async (req, res) => {
     return res.status(200).render('createProfile');
-})
+  }
+);
 
 router.get('/private', redirectIfNotAuthorizedMiddleware, (req, res) => {
-    res.render('private', {});
+  res.render('private', {});
 });
 
 module.exports = router;