Feature/ Add "series" to link related articles

app/(editor)/create/[[...paramsArr]]/_client.tsx

@@ -161,6 +161,7 @@ const Create = ({ session }: { session: Session | null }) => {
       Sentry.captureException(error);
     },
   });
+
   const {
     mutate: create,
     data: createData,
@@ -217,6 +218,7 @@ const Create = ({ session }: { session: Session | null }) => {
       tags,
       canonicalUrl: data.canonicalUrl || undefined,
       excerpt: data.excerpt || removeMarkdown(data.body, {}).substring(0, 155),
+      seriesName: data.seriesName || undefined
     };
     return formData;
   };
@@ -229,6 +231,7 @@ const Create = ({ session }: { session: Session | null }) => {
       await create({ ...formData });
     } else {
       await save({ ...formData, id: postId });
+
       setSavedTime(
         new Date().toLocaleString(undefined, {
           dateStyle: "medium",
@@ -564,10 +567,24 @@ const Create = ({ session }: { session: Session | null }) => {
                                   {copied ? "Copied" : "Copy Link"}
                                 </div>
                               </button>
-                              <p className="mt-2 text-sm text-neutral-600 dark:text-neutral-400">
+                              <p className="mt-2 mb-2 text-sm text-neutral-600 dark:text-neutral-400">
                                 Share this link with others to preview your
                                 draft. Anyone with the link can view your draft.
                               </p>
+
+                              <label htmlFor="seriesName">
+                                Series Name
+                              </label>
+                              <input
+                                id="seriesName"
+                                type="text"
+                                placeholder="The name of my series"
+                                defaultValue={data?.series?.name || ""}
+                                {...register("seriesName")}
+                              />
+                              <p className="mt-2 text-sm text-neutral-600 dark:text-neutral-400">
+                              This text is case-sensitive so make sure you type it exactly as you did in previous articles to ensure they are connected
+                              </p>
                             </DisclosurePanel>
                           </>
                         )}

drizzle/0011_add_series_update_post.sql

@@ -0,0 +1,18 @@
+-- Create Series table
+CREATE TABLE IF NOT EXISTS "Series" (
+  "id" SERIAL PRIMARY KEY,
+  "name" TEXT NOT NULL,
+  "userId" text NOT NULL,
+  "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL,
+  "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL
+);
+-- Update Post table to add seriesId column
+ALTER TABLE "Post"
+ADD COLUMN "seriesId" INTEGER
+ADD CONSTRAINT fk_post_series
+    FOREIGN KEY ("seriesId")
+    REFERENCES "Series" ("id")
+    ON DELETE SET NULL;
+CREATE INDEX idx_post_series ON "Post"("seriesId");
+CREATE INDEX idx_series_name ON "Series"("name");
+ALTER TABLE series ADD CONSTRAINT unique_series_name_per_user UNIQUE (name, userId);

schema/post.ts

@@ -25,6 +25,9 @@ export const SavePostSchema = z.object({
   canonicalUrl: z.optional(z.string().trim().url()),
   tags: z.string().array().max(5).optional(),
   published: z.string().datetime().optional(),
+  seriesName: z.string()
+    .trim()
+    .optional()
 });
 
 export const PublishPostSchema = z.object({

schema/series.ts

@@ -0,0 +1,6 @@
+import z from "zod";
+
+export const UpdateSeriesSchema = z.object({
+    postId: z.string(),
+    seriesName: z.string().trim().optional()
+});

server/api/router/index.ts

@@ -15,7 +15,7 @@ export const appRouter = createTRPCRouter({
   notification: notificationRouter,
   admin: adminRouter,
   report: reportRouter,
-  tag: tagRouter,
+  tag: tagRouter
 });
 
 // export type definition of API

server/api/router/post.ts

@@ -14,7 +14,7 @@ import {
   GetLimitSidePosts,
 } from "../../../schema/post";
 import { removeMarkdown } from "../../../utils/removeMarkdown";
-import { bookmark, like, post, post_tag, tag, user } from "@/server/db/schema";
+import { bookmark, like, post, post_tag, tag, user, series } from "@/server/db/schema";
 import {
   and,
   eq,
@@ -52,10 +52,13 @@ export const postRouter = createTRPCRouter({
   update: protectedProcedure
     .input(SavePostSchema)
     .mutation(async ({ input, ctx }) => {
-      const { id, body, title, excerpt, canonicalUrl, tags = [] } = input;
+      const { id, body, title, excerpt, canonicalUrl, tags = [], seriesName } = input;
 
       const currentPost = await ctx.db.query.post.findFirst({
         where: (posts, { eq }) => eq(posts.id, id),
+        with: {
+          series: true
+        },
       });
 
       if (currentPost?.userId !== ctx.session.user.id) {
@@ -64,6 +67,94 @@ export const postRouter = createTRPCRouter({
         });
       }
 
+      // series 
+      const postId = currentPost.id;
+
+      if (seriesName?.trim() === "") {
+        throw new TRPCError({ code: 'BAD_REQUEST', message: 'Series name cannot be empty' });
+      }
+
+      const createNewSeries = async (seriesTitle: string) => {
+        return await ctx.db.transaction(async (tx) => {
+          let seriesId: number;
+          const currSeries = await tx.query.series.findFirst({
+            columns: {
+              id: true
+            },
+            where: (series, { eq, and }) => and(
+              eq(series.name, seriesTitle),
+              eq(series.userId, ctx.session.user.id)
+            ),
+          })
+
+          if (!currSeries) {
+            const [newSeries] = await tx.insert(series).values({
+              name: seriesTitle,
+              userId: ctx.session.user.id,
+              updatedAt: new Date()
+            }).returning();
+
+            seriesId = newSeries.id;
+          }
+          else {
+            seriesId = currSeries.id;
+          }
+          await tx
+            .update(post)
+            .set({
+              seriesId: seriesId
+            })
+            .where(eq(post.id, currentPost.id));
+        })
+
+      }
+
+      const unlinkSeries = async (seriesId: number) => {
+        return await ctx.db.transaction(async (tx) => {
+          const anotherPostInThisSeries = await tx.query.post.findFirst({
+            where: (post, { eq, and, ne }) =>
+              and(
+                ne(post.id, currentPost.id),
+                eq(post.seriesId, seriesId)
+              )
+          })
+          if (!anotherPostInThisSeries) {
+            await tx.delete(series).where(
+              and(
+                eq(series.id, seriesId),
+                eq(series.userId, ctx.session.user.id)
+              )
+            );
+          }
+          // update that series id in the current post
+          await tx
+            .update(post)
+            .set({
+              seriesId: null
+            })
+            .where(eq(post.id, currentPost.id));
+        })
+      }
+
+      if (seriesName) {
+        if (currentPost?.seriesId) {
+          if (currentPost?.series?.name !== seriesName) {
+            await unlinkSeries(currentPost.seriesId);
+            await createNewSeries(seriesName);
+          }
+        }
+        else {
+          await createNewSeries(seriesName);
+        }
+      }
+      else {
+        if (currentPost.seriesId !== null) {
+          await unlinkSeries(currentPost.seriesId);
+        }
+      }
+
+
+
       // if user doesnt link any tags to the article no point in doing the tag operations
       // This also makes autosave during writing faster
       if (tags.length > 0) {
@@ -105,7 +196,7 @@ export const postRouter = createTRPCRouter({
           return excerpt && excerpt.length > 0
             ? excerpt
             : // @Todo why is body string | null ?
-              removeMarkdown(currentPost.body as string, {}).substring(0, 156);
+            removeMarkdown(currentPost.body as string, {}).substring(0, 156);
         }
         return excerpt;
       };
@@ -187,10 +278,27 @@ export const postRouter = createTRPCRouter({
         });
       }
 
-      const [deletedPost] = await ctx.db
-        .delete(post)
-        .where(eq(post.id, id))
-        .returning();
+      const deletedPost = await ctx.db.transaction(async (tx) => {
+        const [deletedPost] = await tx
+          .delete(post)
+          .where(eq(post.id, id))
+          .returning();
+
+        if (deletedPost.seriesId) {
+          // check is there is any other post with the current seriesId
+          const anotherPostInThisSeries = await tx.query.post.findFirst({
+            where: (post, { eq }) =>
+              eq(post.seriesId, deletedPost.seriesId!)
+          })
+          // if another post with the same seriesId is present, then do nothing
+          // else remove the series from the series table
+          if (!anotherPostInThisSeries) {
+            await tx.delete(series).where(eq(series.id, deletedPost.seriesId));
+          }
+        }
+
+        return deletedPost;
+      });
 
       return deletedPost;
     }),
@@ -203,33 +311,33 @@ export const postRouter = createTRPCRouter({
 
       setLiked
         ? await ctx.db.transaction(async (tx) => {
-            res = await tx.insert(like).values({ postId, userId }).returning();
+          res = await tx.insert(like).values({ postId, userId }).returning();
+          await tx
+            .update(post)
+            .set({
+              likes: increment(post.likes),
+            })
+            .where(eq(post.id, postId));
+        })
+        : await ctx.db.transaction(async (tx) => {
+          res = await tx
+            .delete(like)
+            .where(
+              and(
+                eq(like.postId, postId),
+                eq(like.userId, ctx.session?.user?.id),
+              ),
+            )
+            .returning();
+          if (res.length !== 0) {
             await tx
               .update(post)
               .set({
-                likes: increment(post.likes),
+                likes: decrement(post.likes),
               })
               .where(eq(post.id, postId));
-          })
-        : await ctx.db.transaction(async (tx) => {
-            res = await tx
-              .delete(like)
-              .where(
-                and(
-                  eq(like.postId, postId),
-                  eq(like.userId, ctx.session?.user?.id),
-                ),
-              )
-              .returning();
-            if (res.length !== 0) {
-              await tx
-                .update(post)
-                .set({
-                  likes: decrement(post.likes),
-                })
-                .where(eq(post.id, postId));
-            }
-          });
+          }
+        });
 
       return res;
     }),
@@ -241,16 +349,16 @@ export const postRouter = createTRPCRouter({
 
       setBookmarked
         ? await ctx.db
-            .insert(bookmark)
-            .values({ postId, userId: ctx.session?.user?.id })
+          .insert(bookmark)
+          .values({ postId, userId: ctx.session?.user?.id })
         : await ctx.db
-            .delete(bookmark)
-            .where(
-              and(
-                eq(bookmark.postId, postId),
-                eq(bookmark.userId, ctx.session?.user?.id),
-              ),
-            );
+          .delete(bookmark)
+          .where(
+            and(
+              eq(bookmark.postId, postId),
+              eq(bookmark.userId, ctx.session?.user?.id),
+            ),
+          );
       return res;
     }),
   sidebarData: publicProcedure
@@ -267,26 +375,26 @@ export const postRouter = createTRPCRouter({
           // if user not logged in and they wont have any liked posts so default to a count of 0
           ctx.session?.user?.id
             ? ctx.db
-                .selectDistinct()
-                .from(like)
-                .where(
-                  and(
-                    eq(like.postId, id),
-                    eq(like.userId, ctx.session.user.id),
-                  ),
-                )
+              .selectDistinct()
+              .from(like)
+              .where(
+                and(
+                  eq(like.postId, id),
+                  eq(like.userId, ctx.session.user.id),
+                ),
+              )
             : [false],
           // if user not logged in and they wont have any bookmarked posts so default to a count of 0
           ctx.session?.user?.id
             ? ctx.db
-                .selectDistinct()
-                .from(bookmark)
-                .where(
-                  and(
-                    eq(bookmark.postId, id),
-                    eq(bookmark.userId, ctx.session.user.id),
-                  ),
-                )
+              .selectDistinct()
+              .from(bookmark)
+              .where(
+                and(
+                  eq(bookmark.postId, id),
+                  eq(bookmark.userId, ctx.session.user.id),
+                ),
+              )
             : [false],
         ]);
       return {
@@ -428,6 +536,7 @@ export const postRouter = createTRPCRouter({
         where: (posts, { eq }) => eq(posts.id, id),
         with: {
           tags: { with: { tag: true } },
+          series: true
         },
       });