feat: user activation and emails

app/api/confirmation/route.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import prisma from '../../../prisma/prisma';
+import { ApiResponse } from '../../../utils/apiResponse';
+import { ConfirmationSchema, ResponseSchema } from '../../../utils/types';
+
+export const dynamic = 'force-dynamic'; // defaults to force-static
+export async function POST(request: Request) {
+  const body = await request.json();
+  const validation = ConfirmationSchema.safeParse(body);
+  if (!validation.success || !validation.data.code) {
+    return ApiResponse(400, 'Bad request');
+  }
+
+  const user = await prisma.user.findUnique({
+    where: {
+      code: validation.data.code
+    }
+  });
+
+  if (user) {
+    await prisma.user.update({
+      where: {
+        code: validation.data.code
+      },
+      data: {
+        confirmed: true
+      }
+    });
+
+    const message: z.infer<typeof ResponseSchema> = {
+      message: `Thank you for confirming the subscripion!`
+    };
+
+    return ApiResponse(200, JSON.stringify(message));
+  }
+
+  const message: z.infer<typeof ResponseSchema> = {
+    message: `Nothing to see here...`
+  };
+
+  return ApiResponse(200, JSON.stringify(message));
+}

app/api/cron/route.ts

@@ -1,8 +1,10 @@
 import { NextResponse } from 'next/server';
 import { z } from 'zod';
+import NewsletterEmail from '../../../components/emails/newsletter';
 import prisma from '../../../prisma/prisma';
-import { NewsSchema } from '../../utils/types';
-import { singleNews, topNews } from '../../utils/urls';
+import { sendEmail } from '../../../utils/sender';
+import { NewsSchema } from '../../../utils/types';
+import { singleNews, topNews } from '../../../utils/urls';
 
 export async function GET(request: Request) {
   if (
@@ -11,47 +13,22 @@ export async function GET(request: Request) {
     return new Response('Unauthorized', { status: 401 });
   }
 
-  const response = await hackernewsApi();
-
-  return new NextResponse(JSON.stringify(response), {
-    status: 200
-  });
-}
-
-async function hackernewsApi() {
   const topstories: number[] = await fetch(topNews).then(res => res.json());
 
-  console.log('topstories', topstories);
-
   const newsPromises = topstories
     .splice(0, Number(process.env.NEWS_LIMIT))
     .map(async id => {
-      console.log('id', id);
       const sourceNews: z.infer<typeof NewsSchema> = await fetch(
         singleNews(id)
       ).then(res => res.json());
 
-      console.log('sourceNews', sourceNews);
-
       return await prisma.news.upsert({
         create: {
-          id,
-          title: sourceNews.title,
-          text: sourceNews.text,
-          type: sourceNews.type,
-          by: sourceNews.by,
-          time: sourceNews.time,
-          url: sourceNews.url,
-          score: sourceNews.score
+          ...sourceNews,
+          id
         },
         update: {
-          title: sourceNews.title,
-          text: sourceNews.text,
-          type: sourceNews.type,
-          by: sourceNews.by,
-          time: sourceNews.time,
-          url: sourceNews.url,
-          score: sourceNews.score
+          ...sourceNews
         },
         where: {
           id
@@ -64,5 +41,30 @@ async function hackernewsApi() {
 
   const newsIds = await Promise.all(newsPromises);
 
-  return newsIds.map(news => news.id);
+  const users = await prisma.user.findMany({
+    where: {
+      email: 'riccardo.s@hey.com',
+      confirmed: true,
+      deleted: false
+    },
+    select: {
+      email: true
+    }
+  });
+
+  if (!users) {
+    return new NextResponse('No users.', {
+      status: 200
+    });
+  }
+
+  await sendEmail(
+    users.map(user => user.email),
+    `What's new from Hackernews?`,
+    NewsletterEmail(newsIds.map(news => news.id))
+  );
+
+  return new NextResponse(`Newsletter sent to ${users.length} addresses.`, {
+    status: 200
+  });
 }

app/api/subscribe/route.ts

@@ -1,34 +1,70 @@
+import * as crypto from 'crypto';
 import { z } from 'zod';
-import { fromZodError } from 'zod-validation-error';
+import SubscribeEmail from '../../../components/emails/subscribe';
 import prisma from '../../../prisma/prisma';
-import { ResponseSchema, SubscribeFormSchema } from '../../utils/types';
+import { ApiResponse } from '../../../utils/apiResponse';
+import { sendEmail } from '../../../utils/sender';
+import { ResponseSchema, SubscribeFormSchema } from '../../../utils/types';
 
 export const dynamic = 'force-dynamic'; // defaults to force-static
 export async function POST(request: Request) {
   const body = await request.json();
   const validation = SubscribeFormSchema.safeParse(body);
   if (!validation.success) {
-    const message = fromZodError(validation.error);
-    return new Response(message.message, { status: 400 });
+    return ApiResponse(400, 'Bad request');
   }
 
-  const { email, targetingAllowed } = validation.data;
+  const { email } = validation.data;
+
+  const userAlreadyConfirmed = await prisma.user.findUnique({
+    where: {
+      email,
+      confirmed: true
+    }
+  });
+
+  if (userAlreadyConfirmed) {
+    if (userAlreadyConfirmed.deleted) {
+      await prisma.user.update({
+        where: {
+          email
+        },
+        data: {
+          deleted: false
+        }
+      });
+    }
+
+    const message: z.infer<typeof ResponseSchema> = {
+      message: `Thank you for subscribing!`
+    };
+
+    return ApiResponse(200, JSON.stringify(message));
+  }
+
+  const code = crypto
+    .createHash('sha256')
+    .update(`${process.env.SECRET_HASH}${email}}`)
+    .digest('hex');
 
   await prisma.user.upsert({
     create: {
       email,
-      targetingAllowed
+      code
     },
     update: {
-      targetingAllowed
+      code
     },
     where: {
       email
     }
   });
 
+  await sendEmail([email], 'Welcome!', SubscribeEmail(code));
+
   const message: z.infer<typeof ResponseSchema> = {
-    message: `${email} subscribed!`
+    message: `Thank you! You will now receive an email to ${email} to confirm the subscription.`
   };
-  return new Response(JSON.stringify(message), { status: 200 });
+
+  return ApiResponse(200, JSON.stringify(message));
 }

app/api/unsubscribe/route.ts

@@ -1,31 +1,42 @@
 import { z } from 'zod';
-import { fromZodError } from 'zod-validation-error';
+import UnsubscribeEmail from '../../../components/emails/unsubscribe';
 import prisma from '../../../prisma/prisma';
-import { ResponseSchema, UnsubscribeFormSchema } from '../../utils/types';
+import { ApiResponse } from '../../../utils/apiResponse';
+import { sendEmail } from '../../../utils/sender';
+import { ResponseSchema, UnsubscribeFormSchema } from '../../../utils/types';
 
 export const dynamic = 'force-dynamic'; // defaults to force-static
 export async function POST(request: Request) {
   const body = await request.json();
   const validation = UnsubscribeFormSchema.safeParse(body);
   if (!validation.success) {
-    const message = fromZodError(validation.error);
-    return new Response(message.message, { status: 400 });
+    return ApiResponse(400, 'Bad request');
   }
 
   const { email } = validation.data;
 
-  try {
-    await prisma.user.delete({
+  const user = await prisma.user.findUnique({
+    where: {
+      email
+    }
+  });
+
+  if (user && !user.deleted) {
+    await prisma.user.update({
       where: {
         email
+      },
+      data: {
+        deleted: true
       }
     });
-  } catch (err) {
-    console.log(err);
+
+    sendEmail([email], 'Unsubscribe confirmation', UnsubscribeEmail());
   }
 
   const message: z.infer<typeof ResponseSchema> = {
-    message: `${email} unsubscribe!`
+    message: `${email} unsubscribed!`
   };
-  return new Response(JSON.stringify(message), { status: 200 });
+
+  return ApiResponse(200, JSON.stringify(message));
 }