start api routes

This commit is contained in:
counterweight 2025-03-05 16:04:44 +01:00
parent db97f9fd80
commit c923493108
Signed by: counterweight
GPG key ID: 883EDBAA726BD96C
3 changed files with 290 additions and 273 deletions

View file

@ -18,11 +18,8 @@ function createApp(dependencies) {
app.use(dependencies.middlewares.createSessionMiddleware); app.use(dependencies.middlewares.createSessionMiddleware);
const webRoutes = dependencies.webRoutes; app.use('/', dependencies.webRoutes);
const apiRoutes = require('./routes/apiRoutes'); app.use('/api', dependencies.apiRoutes);
app.use('/', webRoutes);
app.use('/api', apiRoutes);
app.use(express.static(path.join(__dirname, 'public'))); app.use(express.static(path.join(__dirname, 'public')));

View file

@ -15,6 +15,10 @@ function buildDependencies() {
invitesService, invitesService,
}); });
dependencies.webRoutes = webRoutesProvider.provide(); dependencies.webRoutes = webRoutesProvider.provide();
const ApiRoutesProvider = require('./routes/apiRoutes');
const apiRoutesProvider = new ApiRoutesProvider();
dependencies.apiRoutes = apiRoutesProvider.provide();
return dependencies; return dependencies;
} }

View file

@ -16,282 +16,298 @@ const profileService = profileServiceProvider(ContactDetailsSet, NymSet);
const router = express.Router(); const router = express.Router();
router.get('/signup/nostr-challenge', async (req, res) => { class ApiRoutesProvider {
const inviteUuid = req.cookies.inviteUuid; constructor() {}
let signUpChallenge; provide() {
try { router.get('/signup/nostr-challenge', async (req, res) => {
signUpChallenge = await invitesService.createSignUpChallenge(inviteUuid); const inviteUuid = req.cookies.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) { let signUpChallenge;
return res.status(410).json({ try {
success: false, signUpChallenge =
message: 'That invite has already been used.', 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.',
});
}
return res.status(500).json({ if (error instanceof errors.AlreadyUsedError) {
success: false, return res.status(410).json({
message: 'Unexpected error.', success: false,
}); message: 'That invite has already been used.',
} });
}
let relatedNostrChallenge; return res.status(500).json({
try {
relatedNostrChallenge = await nostrService.getNostrChallenge(
signUpChallenge.nostr_challenge_uuid
);
} catch (error) {
return res.status(500).json({
success: false,
message: `Unexpected error: ${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;
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
);
return res.status(200).json({ success: true });
});
router.get('/login/nostr-challenge', async (req, res) => {
let loginChallenge;
try {
loginChallenge = await loginService.createLoginChallenge();
} catch (error) {
return res.status(500).json({
success: false,
message: 'Unexpected error.',
});
}
let relatedNostrChallenge;
try {
relatedNostrChallenge = await nostrService.getNostrChallenge(
loginChallenge.nostr_challenge_uuid
);
} catch (error) {
return res.status(500).json({
success: false,
message: `Unexpected error: ${error}`,
});
}
return res.status(200).json({ challenge: relatedNostrChallenge.challenge });
});
router.post('/login/nostr-verify', async (req, res) => {
const signedEvent = req.body;
const sessionUuid = req.cookies.sessionUuid;
let completedLoginChallenge;
try {
completedLoginChallenge =
await loginService.verifyLoginChallenge(signedEvent);
} catch (error) {
console.log('helo5');
console.log(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.',
});
}
if (error instanceof errors.ForbiddenError) {
console.log('helo?1');
return res.status(403).json({
success: false,
message: 'This public key is not authorized.',
});
}
return res.status(500).json({
success: false,
message: 'Unexpected error.',
});
}
console.log('helo?2');
console.log(completedLoginChallenge);
await sessionService.relateSessionToPublicKey(
sessionUuid,
completedLoginChallenge.public_key
);
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;
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;
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.',
});
}
);
router.post(
'/offer',
rejectIfNotAuthorizedMiddleware,
attachPublicKeyMiddleware,
async (req, res) => {
const publicKey = req.cookies.publicKey;
const offerDetails = req.body.offerDetails;
await offerService.createOffer(publicKey, offerDetails);
return res.status(200).json({
success: true,
message: 'Offer created successfully',
});
}
);
router.delete(
'/offer/:offerUuid',
rejectIfNotAuthorizedMiddleware,
attachPublicKeyMiddleware,
async (req, res) => {
const offerUuid = req.params.offerUuid;
try {
await offerService.deleteOffer(offerUuid);
} catch (error) {
if (error instanceof errors.NotFoundError) {
return res.status(404).json({
success: false, success: false,
message: 'Offer not found for the given public key.', message: 'Unexpected error.',
}); });
} }
return res.status(500).json({
success: false,
message: 'Unexpected error.',
});
}
return res.status(204).json({ let relatedNostrChallenge;
success: true, try {
message: 'Offer deleted successfully', relatedNostrChallenge = await nostrService.getNostrChallenge(
signUpChallenge.nostr_challenge_uuid
);
} catch (error) {
return res.status(500).json({
success: false,
message: `Unexpected error: ${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;
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
);
return res.status(200).json({ success: true });
});
router.get('/login/nostr-challenge', async (req, res) => {
let loginChallenge;
try {
loginChallenge = await loginService.createLoginChallenge();
} catch (error) {
return res.status(500).json({
success: false,
message: 'Unexpected error.',
});
}
let relatedNostrChallenge;
try {
relatedNostrChallenge = await nostrService.getNostrChallenge(
loginChallenge.nostr_challenge_uuid
);
} catch (error) {
return res.status(500).json({
success: false,
message: `Unexpected error: ${error}`,
});
}
return res
.status(200)
.json({ challenge: relatedNostrChallenge.challenge });
});
router.post('/login/nostr-verify', async (req, res) => {
const signedEvent = req.body;
const sessionUuid = req.cookies.sessionUuid;
let completedLoginChallenge;
try {
completedLoginChallenge =
await loginService.verifyLoginChallenge(signedEvent);
} catch (error) {
console.log('helo5');
console.log(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.',
});
}
if (error instanceof errors.ForbiddenError) {
console.log('helo?1');
return res.status(403).json({
success: false,
message: 'This public key is not authorized.',
});
}
return res.status(500).json({
success: false,
message: 'Unexpected error.',
});
}
console.log('helo?2');
console.log(completedLoginChallenge);
await sessionService.relateSessionToPublicKey(
sessionUuid,
completedLoginChallenge.public_key
);
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;
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;
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.',
});
}
);
router.post(
'/offer',
rejectIfNotAuthorizedMiddleware,
attachPublicKeyMiddleware,
async (req, res) => {
const publicKey = req.cookies.publicKey;
const offerDetails = req.body.offerDetails;
await offerService.createOffer(publicKey, offerDetails);
return res.status(200).json({
success: true,
message: 'Offer created successfully',
});
}
);
router.delete(
'/offer/:offerUuid',
rejectIfNotAuthorizedMiddleware,
attachPublicKeyMiddleware,
async (req, res) => {
const offerUuid = req.params.offerUuid;
try {
await offerService.deleteOffer(offerUuid);
} catch (error) {
if (error instanceof errors.NotFoundError) {
return res.status(404).json({
success: false,
message: 'Offer not found for the given public key.',
});
}
return res.status(500).json({
success: false,
message: 'Unexpected error.',
});
}
return res.status(204).json({
success: true,
message: 'Offer deleted successfully',
});
}
);
router.get(
'/publickey-offers',
rejectIfNotAuthorizedMiddleware,
attachPublicKeyMiddleware,
async (req, res) => {
console.log('elo');
const publicKey = req.cookies.publicKey;
const offers = await offerService.getOffersByPublicKey(publicKey);
if (!offers) {
return res.status(404).json({
success: true,
message: 'No offers posted by this public key.',
});
}
if (offers) {
return res.status(200).json({
success: true,
message: 'Offers found',
data: offers,
});
}
}
);
return router;
} }
); }
router.get( module.exports = ApiRoutesProvider;
'/publickey-offers',
rejectIfNotAuthorizedMiddleware,
attachPublicKeyMiddleware,
async (req, res) => {
console.log('elo');
const publicKey = req.cookies.publicKey;
const offers = await offerService.getOffersByPublicKey(publicKey);
if (!offers) {
return res.status(404).json({
success: true,
message: 'No offers posted by this public key.',
});
}
if (offers) {
return res.status(200).json({
success: true,
message: 'Offers found',
data: offers,
});
}
}
);
module.exports = router;