- {tags.slice(0, count).map((tag, index) => (
-
- ))}
+
+
+
+
+
{_t("Home")}
+
+
+
+
{_t("Bookmarks")}
+
+
+
+
{_t("New diary")}
+
- {count === 10 && (
-
- )}
+
+
+ {_t("Top tags")}
+
+
+
+ {tags.slice(0, count).map((tag, index) => (
+
+
+
{tag?.label}
+
+ ))}
+
+
+ {count === 10 && (
+
+ )}
+
);
};
-
-export default TagsWidget;
diff --git a/src/app/(home)/_components/HomeRightSidebar.tsx b/src/app/(home)/_components/HomeRightSidebar.tsx
new file mode 100644
index 0000000..4453bc3
--- /dev/null
+++ b/src/app/(home)/_components/HomeRightSidebar.tsx
@@ -0,0 +1,18 @@
+import DiscordWidget from "@/components/widgets/DiscordWidget";
+import ImportantLinksWidget from "@/components/widgets/ImportantLinksWidget";
+import LatestUsers from "@/components/widgets/LatestUsers";
+import SocialLinksWidget from "@/components/widgets/SocialLinksWidget";
+import React from "react";
+
+const HomeRightSidebar = () => {
+ return (
+
+
+
+
+
+
+ );
+};
+
+export default HomeRightSidebar;
diff --git a/src/app/(home)/_components/SidebarToggleButton.tsx b/src/app/(home)/_components/SidebarToggleButton.tsx
new file mode 100644
index 0000000..f2abcfd
--- /dev/null
+++ b/src/app/(home)/_components/SidebarToggleButton.tsx
@@ -0,0 +1,17 @@
+"use client";
+
+import { homeSidebarOpenAtom } from "@/store/home-sidebar.atom";
+import { useAtom } from "jotai";
+import { MenuIcon } from "lucide-react";
+
+const SidebarToggleButton = () => {
+ const [open, setOpen] = useAtom(homeSidebarOpenAtom);
+
+ return (
+
+ );
+};
+
+export default SidebarToggleButton;
diff --git a/src/app/(home)/components/ArticleCard.tsx b/src/app/(home)/components/ArticleCard.tsx
deleted file mode 100644
index 7d3960e..0000000
--- a/src/app/(home)/components/ArticleCard.tsx
+++ /dev/null
@@ -1,266 +0,0 @@
-"use client";
-
-import { useClipboard, useSetState } from "@mantine/hooks";
-
-import useShare from "@/hooks/useShare";
-import { notifications } from "@mantine/notifications";
-
-import { relativeTime } from "@/utils/relativeTime";
-import { HoverCard, Menu, Text } from "@mantine/core";
-import { useMutation } from "@tanstack/react-query";
-import Link from "next/link";
-import React from "react";
-import { AiFillFacebook } from "react-icons/ai";
-import { FiCopy } from "react-icons/fi";
-import { LiaCommentsSolid } from "react-icons/lia";
-import { RiTwitterFill } from "react-icons/ri";
-
-import useVote from "@/hooks/useVote";
-import classNames from "clsx";
-
-import AppImage from "@/components/AppImage";
-import UserHoverCard from "@/components/UserHoverCard";
-import { IArticleFeedItem } from "@/http/models/Article.model";
-import { BookmarkRepository } from "@/http/repositories/bookmark.repository";
-import { useTranslation } from "@/i18n/use-translation";
-import { userAtom } from "@/store/user.atom";
-import {
- BookmarkFilledIcon,
- BookmarkIcon,
- ChevronDownIcon,
- ChevronUpIcon,
- Share2Icon,
-} from "@radix-ui/react-icons";
-import { useAtomValue } from "jotai";
-
-interface Props {
- article: IArticleFeedItem;
-}
-
-const ArticleCard: React.FC
= ({ article }) => {
- const { _t } = useTranslation();
- const bookmarkRepository = new BookmarkRepository();
- const currentUser = useAtomValue(userAtom);
- const clipboard = useClipboard({ timeout: 100 });
-
- const [state, setState] = useSetState({
- bookmarked_users: article?.bookmarked_users,
- });
-
- const toogleBookmarkState = (bookmarked?: boolean) => {
- if (state.bookmarked_users?.includes(currentUser?.id!)) {
- setState({
- bookmarked_users: state.bookmarked_users?.filter(
- (id) => id !== currentUser?.id!
- ),
- });
- } else {
- setState({
- bookmarked_users: [...state.bookmarked_users, currentUser?.id!],
- });
- }
- };
-
- const { mutate: mutate__createBookmark } = useMutation({
- mutationFn: (id: string) => {
- toogleBookmarkState();
- return bookmarkRepository.createBook({
- model_name: "ARTICLE",
- model_id: id,
- });
- },
- onSuccess: (res) => {
- if (res?.data?.bookmarked) {
- setState({
- bookmarked_users: [...state.bookmarked_users, currentUser?.id!],
- });
- } else {
- setState({
- bookmarked_users: state.bookmarked_users?.filter(
- (id) => id !== currentUser?.id!
- ),
- });
- }
- },
- });
-
- const { share } = useShare(article.url);
- const { voteState } = useVote({
- modelName: "ARTICLE",
- id: article.id,
- data: article.votes,
- });
-
- return (
-
-
- {/* */}
-
-
-
-
-
- 
-
-
-
-
-
-
-
-
-
-
-
- {article?.user?.username}
-
-
-
- {relativeTime(new Date(article?.created_at))}
-
-
-
- {/* */}
-
-
- {/* Bookmark button */}
-
-
-
-
-
- {article?.thumbnail ? (
-
-
-
- ) : null}
-
-
-
-
-
-
-
-
-
- {article?.comments_count}
-
-
-
- {data?.pages.map((page) => {
- return page.data.map((article) => (
-
- ));
- })}
-
-
{
- if (isVisible) {
- fetchNextPage();
- }
- }}
- options={{ rootMargin: "200px" }}
- >
-
-
-
-
-
-
Something went wrong!
-
{JSON.stringify(error, null, 2)}
-
-
-
+
+
-
-
+
+
);
-}
+};
+
+export default Page;
diff --git a/src/app/[username]/(profile)/page.tsx b/src/app/[username]/(profile)/page.tsx
deleted file mode 100644
index 321b925..0000000
--- a/src/app/[username]/(profile)/page.tsx
+++ /dev/null
@@ -1,265 +0,0 @@
-import { http } from "@/http/http.client";
-import {
- FaBehance,
- FaDribbble,
- FaFacebook,
- FaGithub,
- FaInstagram,
- FaLinkedinIn,
- FaMedium,
- FaStackOverflow,
- FaTwitch,
- FaTwitter,
- FaYoutube,
-} from "react-icons/fa";
-import BaseLayout from "@/components/layout/BaseLayout";
-import { IUser } from "@/http/models/User.model";
-import { Link2Icon } from "@radix-ui/react-icons";
-import { NextPage } from "next";
-import React from "react";
-import { markdownToHtml } from "@/utils/markdoc-parser";
-
-interface UserProfilePageProps {
- params: { username: string };
-}
-
-const UserProfilePage: NextPage
= async ({ params }) => {
- // get username from params
- // if there the username is started with @ then remove the @
- const username = params?.username?.startsWith("%40")
- ? params.username.replace("%40", "").toLowerCase()
- : params.username.toLowerCase();
-
- const {
- data: { data: profile },
- status,
- } = await http.get<{ data: IUser }>(`/api/profile/username/${username}`, {
- validateStatus: () => true,
- });
-
- if (status === 404) {
- throw new Error("āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ°āĻāĻžāĻ°ā§ āĻā§āĻāĻā§ āĻĒāĻžāĻā§āĻž āĻ¯āĻžāĻā§āĻā§ āĻ¨āĻž đĨš");
- } else if (status != 200) {
- throw new Error("āĻā§āĻ¨ āĻāĻāĻāĻž āĻ¸āĻŽāĻ¸ā§āĻ¯āĻž āĻšā§ā§āĻā§ đ§");
- }
-
- return (
-
-
-
-
-
-
-
-
-
-
+
+
+
{profile?.name}
+
@{profile?.username}
+
+
+ {profile?.designation && (
+
{profile?.designation}
+ )}
+
+ {profile?.bio && (
+
{profile?.bio}
+ )}
+
+ {/* User infos start */}
+
+ {profile?.website_url && (
+
+ )}
+
+ {profile?.education && (
+
+
+
{profile?.education}
+
+ )}
+
+ {profile?.email && (
+
+
+
{profile?.email}
+
+ )}
+
+ {profile?.location && (
+
+
+
{profile?.location}
+
+ )}
+
+ {/* User infos end */}
+
+ {/* Uer Socials start */}
+
+ {profile?.social_links?.github && (
+
+
+
+ )}
+
+ {profile?.social_links?.facebook && (
+
+
+
+ )}
+
+ {profile?.social_links?.stackOverflow && (
+
+
+
+ )}
+
+ {profile?.social_links?.medium && (
+
+
+
+ )}
+
+ {profile?.social_links?.linkedin && (
+
+
+
+ )}
+
+ {profile?.social_links?.twitter && (
+
+
+
+ )}
+
+ {profile?.social_links?.instagram && (
+
+
+
+ )}
+
+ {profile?.social_links?.behance && (
+
+
+
+ )}
+
+ {profile?.social_links?.dribbble && (
+
+
+
+ )}
+
+ {profile?.social_links?.twitch && (
+
+
+
+ )}
+
+ {profile?.social_links?.youtube && (
+
+
+
+ )}
+
+ {/* User Socials end */}
+
+
+
+
+
+
+ @{username}
+ {" "}
+ đ {_t("Profile not found")}
+
+
+ {_t("The user you are looking for does not exist")}
+
+
+
+ {JSON.stringify(
+ { currentPath: sanitizedUsername(currentPath!), username },
+ null,
+ 2
+ )}
+ */}
+
+
+
+
+
+
+ {children}
+
+
+
{JSON.stringify(profile, null, 2)};
+
+ return (
+
+ {profile?.profile_readme ? (
+
+ ) : (
+
+
+
+ {_t("No profile readme found")}
+
+
+ )}
+
+ );
+};
+
+export default UserProfilePage;
diff --git a/src/app/[username]/[articleHandle]/_components/ArticleSidebar.tsx b/src/app/[username]/[articleHandle]/_components/ArticleSidebar.tsx
new file mode 100644
index 0000000..961a8af
--- /dev/null
+++ b/src/app/[username]/[articleHandle]/_components/ArticleSidebar.tsx
@@ -0,0 +1,16 @@
+import { Article } from "@/backend/models/domain-models";
+import UserInformationCard from "@/components/UserInformationCard";
+import React from "react";
+
+interface Props {
+ article: Article;
+}
+const ArticleSidebar: React.FC = ({ article }) => {
+ return (
+
+
+
+ );
+};
+
+export default ArticleSidebar;
diff --git a/src/app/[username]/[articleHandle]/page.tsx b/src/app/[username]/[articleHandle]/page.tsx
new file mode 100644
index 0000000..1b06957
--- /dev/null
+++ b/src/app/[username]/[articleHandle]/page.tsx
@@ -0,0 +1,102 @@
+import BaseLayout from "@/components/layout/BaseLayout";
+import * as articleActions from "@/backend/services/article.actions";
+import React from "react";
+import { Metadata, NextPage } from "next";
+import HomepageLayout from "@/components/layout/HomepageLayout";
+import HomeLeftSidebar from "@/app/(home)/_components/HomeLeftSidebar";
+import { markdownToHtml } from "@/utils/markdoc-parser";
+import AppImage from "@/components/AppImage";
+import Link from "next/link";
+import { readingTime, removeMarkdownSyntax } from "@/lib/utils";
+import { notFound } from "next/navigation";
+import ArticleSidebar from "./_components/ArticleSidebar";
+
+export const metadata: Metadata = {
+ title: "Article detail",
+};
+
+interface ArticlePageProps {
+ params: Promise<{
+ username: string;
+ articleHandle: string;
+ }>;
+}
+
+const Page: NextPage = async ({ params }) => {
+ const _params = await params;
+ const article = await articleActions.articleDetailByHandle(
+ _params.articleHandle
+ );
+
+ if (!article) {
+ throw notFound();
+ }
+
+ const parsedHTML = markdownToHtml(article?.body ?? "");
+
+ return (
+ }
+ RightSidebar={}
+ >
+ {/* {!article && Article not found
} */}
+
+ {article?.cover_image && (
+
+ )}
+
+ {/* User information */}
+
+
+
+
+
+
+
+ {article?.user?.name}
+
+
+
+ ¡
+
+ {readingTime(removeMarkdownSyntax(article?.body ?? "")!)} min
+ read
+
+
+
+
+
+
+
{article?.title ?? ""}
+
+
+
+
-
- āĻ¸āĻžāĻŽā§āĻĒā§āĻ°āĻ¤āĻŋāĻ āĻ˛ā§āĻāĻž
-
-
- {articles.map((article) => (
-
- {article.title}
-
- ))}
-
-
-
-
-
- }
- >
-
-
- {article?.thumbnail && (
-
- )}
-
-
-
{article.title}
-
-
-
-
-
- {/* */}
-
-
-
-
-
-
-
- āĻĒāĻžāĻ¸āĻ¸ā§ā§āĻžāĻ°ā§āĻĄ āĻā§āĻ˛ā§ āĻā§āĻā§āĻ¨?
-
-
-
- āĻāĻāĻžāĻāĻ¨ā§āĻ āĻ¨āĻŋāĻŦāĻ¨ā§āĻ§āĻ¨ āĻāĻ°ā§āĻ¨
-
-
-
-
-
-
-
- {_t("Forgot password?")}
-
-
-
- {_t("Create an account")}
-
-
-
-
-
-
-
- {_t("Please wail, you are being redirected to the home page")}
-
-
-
-
-
-
- {_t("Already have an account?")}{" "}
-
- {_t("Login")}
-
-
-
-
-
-
-
- āĻĒāĻžāĻ¸āĻ¸ā§ā§āĻžāĻ°ā§āĻĄ āĻā§āĻ˛ā§ āĻā§āĻā§āĻ¨?
-
-
-
- āĻāĻāĻžāĻāĻ¨ā§āĻ āĻ¨āĻŋāĻŦāĻ¨ā§āĻ§āĻ¨ āĻāĻ°ā§āĻ¨
-
-
-
+
+
{_t("Articles")}
+
+
+
+
+
+ {feedInfiniteQuery.isFetching &&
+ Array.from({ length: 10 }).map((_, i) => (
+
+ ))}
+
+ {feedInfiniteQuery.data?.pages.map((page) => {
+ return page?.nodes.map((article) => (
+
+
+
{article.handle}
+
+ {article.title}
+
+ {article.is_published && (
+
+ {_t("Published on")} {formattedTime(article.published_at!)}
+
+ )}
+
+
+ {!article.approved_at && (
+
+ đ§ {_t("āĻ
āĻ¨ā§āĻŽā§āĻĻāĻ¨āĻžāĻ§ā§āĻ¨")}
+
+ )}
+
+ {article.approved_at && (
+
+ â
{_t("āĻ
āĻ¨ā§āĻŽā§āĻĻāĻŋāĻ¤")}
+
+ )}
+
+ {!article.is_published && (
+
+ đ§ {_t("Draft")}
+
+ )}
+
+ {article.is_published && (
+
+ â
{_t("Published")}
+
+ )}
+
+ {/*
+
+
{article?.comments_count || 0}
+
*/}
+
+ {/*
+
+
{article?.votes?.score || 0}
+
*/}
+
+
+
+
+
+
+
+
+
+ {_t("Edit")}
+
+
+
+
+
+
+
+
+
+ ));
+ })}
+
+
+ {feedInfiniteQuery.hasNextPage && (
+
+ )}
+
- {items.map((item) => (
- :
- }
- />
- ))}
-
- );
-};
-
-export default DashboardNavbar;
diff --git a/src/app/dashboard/_components/DashboardScaffold.tsx b/src/app/dashboard/_components/DashboardScaffold.tsx
new file mode 100644
index 0000000..1c7a87d
--- /dev/null
+++ b/src/app/dashboard/_components/DashboardScaffold.tsx
@@ -0,0 +1,97 @@
+import {
+ Sidebar,
+ SidebarContent,
+ SidebarFooter,
+ SidebarGroupContent,
+ SidebarHeader,
+ SidebarMenu,
+ SidebarMenuButton,
+ SidebarMenuItem,
+ SidebarProvider,
+ SidebarTrigger,
+} from "@/components/ui/sidebar";
+import {
+ Calendar,
+ CommandIcon,
+ Home,
+ Inbox,
+ Search,
+ Settings,
+} from "lucide-react";
+import React, { PropsWithChildren } from "react";
+import DashboardSidebar from "./DashboardSidebar";
+import AuthenticatedUserMenu from "@/components/Navbar/AuthenticatedUserMenu";
+import ThemeSwitcher from "@/components/Navbar/ThemeSwitcher";
+import {
+ Tooltip,
+ TooltipContent,
+ TooltipProvider,
+ TooltipTrigger,
+} from "@/components/ui/tooltip";
+import LanguageSwitcher from "@/components/Navbar/LanguageSwitcher";
+
+interface DashboardScaffoldProps {}
+
+const items = [
+ {
+ title: "Home",
+ url: "#",
+ icon: Home,
+ },
+ {
+ title: "Inbox",
+ url: "#",
+ icon: Inbox,
+ },
+ {
+ title: "Calendar",
+ url: "#",
+ icon: Calendar,
+ },
+ {
+ title: "Search",
+ url: "#",
+ icon: Search,
+ },
+ {
+ title: "Settings",
+ url: "#",
+ icon: Settings,
+ },
+];
+
+const DashboardScaffold: React.FC<
+ PropsWithChildren
+> = ({ children }) => {
+ return (
+ <>
+
+
+
+
+
+
+
+
+
+
+
+ +
+ b
+
+
+
+
+
+
{children}
+
+
+ );
+};
+
+export default DashboardScaffold;
diff --git a/src/app/dashboard/_components/DashboardSidebar.tsx b/src/app/dashboard/_components/DashboardSidebar.tsx
new file mode 100644
index 0000000..335b271
--- /dev/null
+++ b/src/app/dashboard/_components/DashboardSidebar.tsx
@@ -0,0 +1,86 @@
+"use client";
+
+import {
+ Sidebar,
+ SidebarContent,
+ SidebarGroup,
+ SidebarGroupContent,
+ SidebarGroupLabel,
+ SidebarMenu,
+ SidebarMenuButton,
+ SidebarMenuItem,
+} from "@/components/ui/sidebar";
+import { useTranslation } from "@/i18n/use-translation";
+import {
+ BellIcon,
+ Bookmark,
+ Home,
+ KeySquareIcon,
+ Settings,
+ Settings2,
+} from "lucide-react";
+import Link from "next/link";
+import { usePathname } from "next/navigation";
+
+const DashboardSidebar = () => {
+ const { _t } = useTranslation();
+ const pathName = usePathname();
+ const items = [
+ {
+ title: _t("Dashboard"),
+ url: "",
+ icon: Home,
+ },
+ {
+ title: _t("Notifications"),
+ url: "/notifications",
+ icon: BellIcon,
+ },
+ {
+ title: _t("Bookmarks"),
+ url: "/bookmarks",
+ icon: Bookmark,
+ },
+ {
+ title: _t("Settings"),
+ url: "/settings",
+ icon: Settings2,
+ },
+ {
+ title: _t("Login Sessions"),
+ url: "/sessions",
+ icon: KeySquareIcon,
+ },
+ ];
+ return (
+
+
+
+ {_t("Dashboard")}
+
+
+ {items.map((item, key) => (
+
+
+
+
+ {item.title}
+
+
+
+ ))}
+
+
+
+
+
+ );
+};
+
+export default DashboardSidebar;
diff --git a/src/app/dashboard/_components/MatrixReport.tsx b/src/app/dashboard/_components/MatrixReport.tsx
new file mode 100644
index 0000000..380be0f
--- /dev/null
+++ b/src/app/dashboard/_components/MatrixReport.tsx
@@ -0,0 +1,64 @@
+"use client";
+
+import { myArticleMatrix } from "@/backend/services/dashboard.action";
+import { Card, CardContent } from "@/components/ui/card";
+import { useTranslation } from "@/i18n/use-translation";
+import { useQuery } from "@tanstack/react-query";
+import { LoaderIcon } from "lucide-react";
+import React from "react";
+
+const MatrixReport = () => {
+ const { _t } = useTranslation();
+
+ const query = useQuery({
+ queryKey: ["dashboard-matrix-report"],
+ queryFn: () => myArticleMatrix(),
+ });
+
+ return (
+
+
{_t("Stats")}
+
+
+
+
+
+ {query.isFetching && (
+
+ )}
+ {query.data?.total_articles}
+
+
+ {_t("Total articles")}
+
+
+
+
+
+
+
+ {query.isFetching && (
+
+ )}
+ {query.data?.total_comments}
+
+
+ {_t("Total post comments")}
+
+
+
+
+ {/*
+
+ 1334
+
+ {_t("Total post reactions")}
+
+
+ */}
+
+
- {/*
{JSON.stringify(initialArticles, null, 2)} */}
- {data?.pages.map((page) => {
- return page.data.map((article) => (
-
-
-
- {article.title}
-
- {article.is_published && (
-
- {_t("Published on")}{" "}
- {relativeTime(new Date(article.published_at))}
-
- )}
-
-
- {!article.is_published && (
-
- đ§ {_t("Draft")}
-
- )}
-
-
-
-
{article?.comments_count || 0}
-
-
-
-
-
{article?.votes?.score || 0}
-
-
-
-
- ));
- })}
-
- {hasNextPage && (
-
{
- if (isVisible) {
- fetchNextPage();
- }
- }}
- options={{ rootMargin: "200px" }}
- >
-
-
-
-
- )}
-
- {data?.data?.map((article) => (
-
-
-
- {article.title}
-
-
-
- ))}
-
CommentBookmarks
;
-};
-
-export default CommentBookmarks;
diff --git a/src/app/dashboard/bookmarks/page.client.tsx b/src/app/dashboard/bookmarks/page.client.tsx
deleted file mode 100644
index 1bbced5..0000000
--- a/src/app/dashboard/bookmarks/page.client.tsx
+++ /dev/null
@@ -1,28 +0,0 @@
-"use client";
-import { BookmarkRepository } from "@/http/repositories/bookmark.repository";
-import { Tabs } from "@mantine/core";
-import { useQuery } from "@tanstack/react-query";
-import React from "react";
-import ArticleBookmarks from "./_components/ArticleBookmarks";
-import CommentBookmarks from "./_components/CommentBookmarks";
-import { useTranslation } from "@/i18n/use-translation";
-
-const BookmarksPage = () => {
- const { _t } = useTranslation();
- return (
-
-
- {_t("Diaries")}
- {_t("Comments")}
-
-
-
-
-
-
-
-
- );
-};
-
-export default BookmarksPage;
diff --git a/src/app/dashboard/bookmarks/page.tsx b/src/app/dashboard/bookmarks/page.tsx
index eaae248..79e8aef 100644
--- a/src/app/dashboard/bookmarks/page.tsx
+++ b/src/app/dashboard/bookmarks/page.tsx
@@ -1,12 +1,13 @@
-import { Metadata } from "next";
-import BookmarksPage from "./page.client";
+import { ExclamationTriangleIcon } from "@radix-ui/react-icons";
+import React from "react";
-export const metadata: Metadata = {
- title: "Bookmarks",
+const BookmarksPage = () => {
+ return (
+
+
+
āĻāĻ āĻĢāĻŋāĻāĻžāĻ° āĻāĻāĻ¨ā§ āĻļā§āĻˇ āĻšā§āĻ¨āĻŋ
+
+ );
};
-const BookmarkPage = () => {
- return ;
-};
-
-export default BookmarkPage;
+export default BookmarksPage;
diff --git a/src/app/dashboard/layout.tsx b/src/app/dashboard/layout.tsx
index 7bdfb95..5e2dc6c 100644
--- a/src/app/dashboard/layout.tsx
+++ b/src/app/dashboard/layout.tsx
@@ -1,16 +1,35 @@
-import { ssrGetMe } from "@/utils/ssr-user";
+import * as sessionActions from "@/backend/services/session.actions";
+import { SidebarProvider } from "@/components/ui/sidebar";
+import { Metadata } from "next";
+import { cookies, headers } from "next/headers";
import { redirect } from "next/navigation";
import React, { PropsWithChildren } from "react";
-import DashboardLayout from "./_components/DashboardLayout";
-import Image from "next/image";
+import DashboardScaffold from "./_components/DashboardScaffold";
+
+export const metadata: Metadata = {
+ title: {
+ default: "Dashboard",
+ template: "%s | TechDiary",
+ },
+};
const layout: React.FC = async ({ children }) => {
- const { status } = await ssrGetMe();
- if (status !== 200) {
- redirect("/auth/login");
+ const _headers = await headers();
+ const currentPath = _headers.get("x-current-path");
+ const session = await sessionActions.getSession();
+
+ const cookieStore = await cookies();
+ const defaultOpen = cookieStore.get("sidebar_state")?.value === "true";
+
+ if (!session?.user) {
+ redirect(`/login?next=${currentPath}`);
}
- return {children};
+ return (
+
+ {children}
+
+ );
};
export default layout;
diff --git a/src/app/dashboard/loading.tsx b/src/app/dashboard/loading.tsx
deleted file mode 100644
index 245e541..0000000
--- a/src/app/dashboard/loading.tsx
+++ /dev/null
@@ -1,12 +0,0 @@
-import Image from "next/image";
-import React from "react";
-
-const loading = () => {
- return (
-
-
-
- );
-};
-
-export default loading;
diff --git a/src/app/dashboard/notifications/page.tsx b/src/app/dashboard/notifications/page.tsx
index d74378c..4bd8632 100644
--- a/src/app/dashboard/notifications/page.tsx
+++ b/src/app/dashboard/notifications/page.tsx
@@ -1,7 +1,12 @@
-import React from "react";
+import { ExclamationTriangleIcon } from "@radix-ui/react-icons";
-const NotificationsPage = () => {
- return NotificationsPage
;
+const NotificationPage = () => {
+ return (
+
+
+
āĻāĻ āĻĢāĻŋāĻāĻžāĻ° āĻāĻāĻ¨ā§ āĻļā§āĻˇ āĻšā§āĻ¨āĻŋ
+
+ );
};
-export default NotificationsPage;
+export default NotificationPage;
diff --git a/src/app/dashboard/page.client.tsx b/src/app/dashboard/page.client.tsx
deleted file mode 100644
index f6e6f64..0000000
--- a/src/app/dashboard/page.client.tsx
+++ /dev/null
@@ -1,170 +0,0 @@
-"use client";
-
-import { IArticleFeedItem } from "@/http/models/Article.model";
-import { PaginatedResponse } from "@/http/models/PaginatedResponse.model";
-import { ArticleApiRepository } from "@/http/repositories/article.repository";
-import { useTranslation } from "@/i18n/use-translation";
-import { relativeTime } from "@/utils/relativeTime";
-import { Loader, Menu, Text } from "@mantine/core";
-import { openConfirmModal } from "@mantine/modals";
-import {
- CardStackIcon,
- ChatBubbleIcon,
- DotsHorizontalIcon,
- Pencil1Icon,
- ThickArrowUpIcon,
-} from "@radix-ui/react-icons";
-import { useInfiniteQuery } from "@tanstack/react-query";
-import Link from "next/link";
-import { useRouter } from "next/navigation";
-import React from "react";
-import { VisibilityObserver } from "reactjs-visibility";
-
-interface IDashboardPageProps {
- initialArticles: PaginatedResponse;
-}
-
-const DashboardPage: React.FC = ({ initialArticles }) => {
- const { _t } = useTranslation();
- const apiRepo = new ArticleApiRepository();
- const router = useRouter();
-
- const { data, fetchNextPage, hasNextPage, refetch } = useInfiniteQuery<
- PaginatedResponse
- >({
- queryKey: ["dashboard-articles"],
- initialData: {
- pageParams: [initialArticles?.meta?.current_page || 1],
- pages: [initialArticles],
- },
- initialPageParam: initialArticles?.meta?.current_page || 1,
- refetchOnMount: true,
- getNextPageParam: (lastPage, allPages) => {
- return allPages.length < lastPage.meta.last_page
- ? lastPage.meta.current_page + 1
- : null;
- },
- queryFn: async ({ pageParam }) => {
- return apiRepo.getMyArticles({
- page: pageParam as number,
- limit: 10,
- });
- },
- });
-
- return (
- <>
- {/* */}
-
- {/*
{JSON.stringify(initialArticles, null, 2)} */}
- {data?.pages.map((page) => {
- return page.data.map((article) => (
-
-
-
{article.id}
-
- {article.title}
-
- {article.is_published && (
-
- {_t("Published on")}{" "}
- {relativeTime(new Date(article.published_at))}
-
- )}
-
-
- {!article.is_published && (
-
- đ§ {_t("Draft")}
-
- )}
-
-
-
-
{article?.comments_count || 0}
-
-
-
-
-
{article?.votes?.score || 0}
-
-
-
-
- ));
- })}
-
- {hasNextPage && (
-
{
- if (isVisible) {
- fetchNextPage();
- }
- }}
- options={{ rootMargin: "200px" }}
- >
-
-
-
-
- )}
-
-
{_t("States")}
-
-
- {_t("Total posts")}
- {articles?.meta?.total || 0}
-
-
- {_t("Total post reactions")}
- {articles?.meta?.counts?.reactions || 0}
-
-
- {_t("Total post comments")}
- {articles?.meta?.counts.comments || 0}
-
-
- {_t("Total post bookmarks")}
- {articles?.meta?.counts.comments || 0}
-
-
-
-
-
- {!Boolean(articles?.meta?.total) && (
-
-
-
-
- {_t("You didn't write any article yet")}
-
-
-
-
-
-
{_t("New diary")}
-
-
-
- )}
-
-
Loading....}>
-
-
-
-
-
- {tokenListQuery.isFetched && tokenListQuery.data?.length == 0 && (
-
-
-
-
- {_t("You didn't create any personal access token yet")}
-
-
-
-
- )}
-
-
- {tokenListQuery.data?.map((token) => (
-
- {token.name}
-
- {_t("Created At")}:{" "}
- {relativeTime(new Date(token.created_at!))}
-
-
- {token.last_used_at && (
-
- {_t("Last used at")}:{" "}
- {relativeTime(new Date(token.last_used_at!))}
-
- )}
-
-
-
- ))}
-
-
-
-
-
-
+
{_t("Login Sessions")}
+
+ {_t(
+ "These are the login sessions of your account. You can use this to revoke access to your account"
+ )}
+ .
+
+ {/*
{JSON.stringify(sessionQuery.data, null, 2)} */}
+
+
+ {sessionQuery.isFetching && (
+
+
+
+ )}
+
+ {sessionQuery.data?.map((session) => (
+
+
+
+
+ {session.device}
+
+
+
+
+ Last active {formattedTime(session.last_action_at!)}
+
+
+
+
IP: {session.ip}
+
+ {authSession?.session?.id == session.id && (
+
+ Current Session
+
+ )}
+
+
+
+ ))}
+
+
+
+
+ {_t("General")}
+ {_t("Social")}
+
+ {_t("Profile Readme")}
+
+
+ Change your password here.
+ Change your password here.
+
+ Change your profile readme here.
+
+
+
);
};
-export default SettingPage;
+export default SettingsPage;
diff --git a/src/app/design-system/page.tsx b/src/app/design-system/page.tsx
new file mode 100644
index 0000000..279efd5
--- /dev/null
+++ b/src/app/design-system/page.tsx
@@ -0,0 +1,149 @@
+import BaseLayout from "@/components/layout/BaseLayout";
+import { Button } from "@/components/ui/button";
+import React from "react";
+
+const DesignSystemPage = () => {
+ return (
+
+
+ {/* Colors Section */}
+
+ Colors
+
+
+
Primary Background
+
+ Primary Foreground
+
+
+
+
Secondary Background
+
+ Secondary Foreground
+
+
+
+
Accent Background
+
+ Accent Foreground
+
+
+
+
Muted Background
+
+ Muted Foreground
+
+
+
+
Destructive
+
+ Destructive Foreground
+
+
+
+
+
+ {/* Typography Section */}
+
+ Typography
+
+
+
Font Families
+
+
Sans Font (Geist Sans)
+
Mono Font (Geist Mono)
+
āĻā§āĻšāĻŋāĻ¨ā§āĻ° āĻŦāĻžāĻāĻ˛āĻž
+
+
+
+
Text Sizes
+
+
Extra Small (text-xs)
+
Small (text-sm)
+
Base (text-base)
+
Large (text-lg)
+
Extra Large (text-xl)
+
2XL (text-2xl)
+
+
+
+
+ {/* Border Radius Section */}
+
+
+ {/* Shadows Section */}
+
+
+ {/* Interactive States */}
+
+ Interactive States
+
+
+
Buttons
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {props.error.message}
+
+
{JSON.stringify(props.error, null, 2)}
+
{"Go back to home"}
+
+
-
-
-
- );
-};
-
-export default GlobalLoadingPage;
diff --git a/src/app/login/page.tsx b/src/app/login/page.tsx
new file mode 100644
index 0000000..2e983e4
--- /dev/null
+++ b/src/app/login/page.tsx
@@ -0,0 +1,27 @@
+import BaseLayout from "@/components/layout/BaseLayout";
+import SocialLoginCard from "@/components/SocialLoginCard";
+import SocialLinksWidget from "@/components/widgets/SocialLinksWidget";
+import _t from "@/i18n/_t";
+import React from "react";
+
+const page = async () => {
+ return (
+
+
+
+
+ {_t("Join Techdiary community")}
+
+
+ {_t(
+ "A community of 5000+ incredible developers is called Techdiary Community"
+ )}
+
+
+
+
+
+
+ );
+};
+
+export default page;
diff --git a/src/backend/database.ts b/src/backend/database.ts
new file mode 100644
index 0000000..3286340
--- /dev/null
+++ b/src/backend/database.ts
@@ -0,0 +1,5 @@
+import "dotenv/config";
+import { drizzle } from "drizzle-orm/node-postgres";
+import * as schema from "./schemas/schemas";
+import { Client as PgClient } from "pg";
+// export const db = drizzle(process.env.DATABASE_URL!, { schema });
diff --git a/src/backend/models/domain-models.ts b/src/backend/models/domain-models.ts
new file mode 100644
index 0000000..9bf2291
--- /dev/null
+++ b/src/backend/models/domain-models.ts
@@ -0,0 +1,69 @@
+export interface User {
+ id: string;
+ name: string;
+ username: string;
+ email: string;
+ profile_photo: string;
+ education: string;
+ designation: string;
+ bio: string;
+ website_url: string;
+ location: string;
+ social_links: any;
+ profile_readme: string;
+ skills: string;
+ created_at: Date;
+ updated_at: Date;
+}
+
+export interface UserSocial {
+ id: number;
+ service: string;
+ service_uid: string;
+
+ user_id: string;
+ created_at: Date;
+ updated_at: Date;
+}
+
+export interface UserSession {
+ id: string;
+ user_id: string;
+ token: string;
+ device?: string;
+ device_type?: string;
+ ip?: string;
+ last_action_at?: Date;
+ created_at: Date;
+}
+
+export interface IServerFile {
+ key: string;
+ provider: "cloudinary" | "direct";
+}
+
+export interface ArticleMetadata {
+ seo: {
+ title?: string;
+ description?: string;
+ keywords?: string[];
+ canonical_url?: string;
+ };
+}
+
+export interface Article {
+ id: string;
+ title: string;
+ handle: string;
+ excerpt?: string | null;
+ body?: string | null;
+ cover_image?: IServerFile | null;
+ is_published: boolean;
+ published_at?: Date | null;
+ approved_at?: Date | null;
+ user?: User | null;
+ metadata?: ArticleMetadata | null;
+ author_id: string;
+ created_at: Date;
+ updated_at: Date;
+}
diff --git a/src/backend/models/models.ts b/src/backend/models/models.ts
new file mode 100644
index 0000000..f2769b6
--- /dev/null
+++ b/src/backend/models/models.ts
@@ -0,0 +1,5 @@
+export enum DatabaseTableName {
+ users = "users",
+ user_socials = "user_socials",
+ user_sessions = "user_sessions",
+}
diff --git a/src/backend/persistence-repositories.ts b/src/backend/persistence-repositories.ts
new file mode 100644
index 0000000..e8a2865
--- /dev/null
+++ b/src/backend/persistence-repositories.ts
@@ -0,0 +1,25 @@
+import { Article, User, UserSession, UserSocial } from "./models/domain-models";
+import { pgClient } from "./persistence/database-drivers/pg.client";
+import { PersistentRepository } from "./persistence/persistence.repository";
+
+export const userRepository = new PersistentRepository("users", pgClient);
+export const articleRepository = new PersistentRepository(
+ "articles",
+ pgClient
+);
+
+export const userSocialRepository = new PersistentRepository(
+ "user_socials",
+ pgClient
+);
+export const userSessionRepository = new PersistentRepository(
+ "user_sessions",
+ pgClient
+);
+
+export const persistenceRepository = {
+ user: userRepository,
+ userSocial: userSocialRepository,
+ userSession: userSessionRepository,
+ article: articleRepository,
+};
diff --git a/src/backend/persistence/database-drivers/PersistenceDriverError.ts b/src/backend/persistence/database-drivers/PersistenceDriverError.ts
new file mode 100644
index 0000000..1235669
--- /dev/null
+++ b/src/backend/persistence/database-drivers/PersistenceDriverError.ts
@@ -0,0 +1,9 @@
+export class PersistenceDriverError extends Error {
+ constructor(
+ message: string,
+ public originalError?: any
+ ) {
+ super(message);
+ this.name = "PersistenceDriverError";
+ }
+}
diff --git a/src/backend/persistence/database-drivers/pg.client.ts b/src/backend/persistence/database-drivers/pg.client.ts
new file mode 100644
index 0000000..98d5e4f
--- /dev/null
+++ b/src/backend/persistence/database-drivers/pg.client.ts
@@ -0,0 +1,103 @@
+import { Pool } from "pg";
+import { IPersistentDriver } from "../persistence-contracts";
+import { buildSafeQuery } from "../persistence-utils";
+import { PersistenceDriverError } from "./PersistenceDriverError";
+import { env } from "@/env";
+
+declare global {
+ var pgClient: IPersistentDriver | undefined;
+}
+
+export class PgDatabaseClient implements IPersistentDriver {
+ private static instance: PgDatabaseClient;
+
+ private pool: Pool;
+
+ private constructor() {
+ try {
+ console.log("Creating new Postgres client");
+ this.pool = new Pool({
+ connectionString: env.DATABASE_URL,
+ });
+
+ // Test the connection
+ this.pool.on("error", (err) => {
+ console.error("Unexpected error on idle client", err);
+ throw new PersistenceDriverError("Database pool error", err);
+ });
+ } catch (error) {
+ throw new PersistenceDriverError(
+ "Failed to initialize database connection",
+ error
+ );
+ }
+ }
+
+ public static getInstance(): PgDatabaseClient {
+ if (!PgDatabaseClient.instance) {
+ PgDatabaseClient.instance = new PgDatabaseClient();
+ }
+ return PgDatabaseClient.instance;
+ }
+
+ /**
+ * Executes a raw SQL query with the provided values.
+ * @param sql
+ * @param values
+ */
+ async executeSQL(sql: string, values: Array): Promise<{ rows: any[] }> {
+ try {
+ if (!sql) {
+ throw new PersistenceDriverError("SQL query is required");
+ }
+
+ console.log({
+ sql,
+ values,
+ });
+
+ const safeSql = buildSafeQuery(sql, values);
+ const client = await this.pool.connect();
+
+ try {
+ const result = await client.query(safeSql);
+ return {
+ rows: result.rows as any[],
+ };
+ } catch (error) {
+ throw new PersistenceDriverError(
+ `Query execution failed: ${sql}`,
+ error
+ );
+ } finally {
+ client.release();
+ }
+ } catch (error) {
+ if (error instanceof PersistenceDriverError) {
+ throw error;
+ }
+ throw new PersistenceDriverError("Database operation failed", error);
+ }
+ }
+
+ /**
+ * Closes the database connection pool
+ */
+ async close(): Promise {
+ try {
+ await this.pool.end();
+ } catch (error) {
+ throw new PersistenceDriverError(
+ "Failed to close database connection",
+ error
+ );
+ }
+ }
+}
+
+// Initialize global database connection
+if (!globalThis.pgClient) {
+ globalThis.pgClient = PgDatabaseClient.getInstance();
+}
+
+export const pgClient = globalThis.pgClient;
diff --git a/src/backend/persistence/persistence-contracts.ts b/src/backend/persistence/persistence-contracts.ts
new file mode 100644
index 0000000..af46ef2
--- /dev/null
+++ b/src/backend/persistence/persistence-contracts.ts
@@ -0,0 +1,112 @@
+interface PaginationMeta {
+ totalCount: number;
+ currentPage: number;
+ hasNextPage: boolean;
+ totalPages: number;
+}
+
+export class AppPaginationResponseDto {
+ nodes: T[];
+ meta: PaginationMeta;
+
+ constructor(data: any, meta: PaginationMeta) {
+ this.meta = meta;
+ this.nodes = data;
+ }
+}
+
+//------------------------------------
+// Pagination
+//------------------------------------
+export enum ISortType {
+ ASC = "ASC",
+ DESC = "DESC",
+}
+
+//------------------------------------
+// Find
+//------------------------------------
+export interface IPersistentCondition {
+ key: keyof T;
+ value: any;
+ operator:
+ | "="
+ | "<"
+ | ">"
+ | "<="
+ | ">="
+ | "<>"
+ | "like"
+ | "ilike"
+ | "in"
+ | "not in";
+}
+export interface IPersistentOrderBy {
+ key: keyof T;
+ direction: "asc" | "desc";
+}
+
+export type SimpleWhere = IPersistentCondition;
+export type CompositeWhere = {
+ OR?: WhereCondition[];
+ AND?: WhereCondition[];
+};
+export type WhereCondition = SimpleWhere | CompositeWhere;
+
+export interface IPersistenceJoin {
+ as: string;
+ joinTo: string;
+ localField: string;
+ foreignField: string;
+ columns: string[];
+}
+
+export interface IPersistentPaginationPayload {
+ where?: WhereCondition;
+ joins?: IPersistenceJoin[];
+ orderBy?: Array>;
+ columns?: Array;
+ limit?: number;
+ offset?: number;
+}
+
+export interface IPersistentQueryPayload {
+ where?: WhereCondition; // No longer allows arrays
+ orderBy?: Array>;
+ columns?: Array;
+}
+
+export interface IPersistentUpdatePayload {
+ where: WhereCondition; // No longer allows arrays
+ data: Partial;
+ columns?: Array;
+}
+
+export interface IPagination {
+ page?: number;
+ limit?: number;
+ where?: WhereCondition; // No longer allows arrays
+ columns?: Array;
+ orderBy?: Array>;
+ joins?: IPersistenceJoin[];
+}
+
+//------------------------------------
+// Driver
+//------------------------------------
+
+export interface IPersistentDriver {
+ executeSQL(
+ sql: string,
+ values: Array
+ ): Promise<{
+ rows: Array;
+ }>;
+}
+
+export enum DatabaseTableName {
+ tenants = "tenants",
+ clients = "clients",
+ users = "users",
+ roles = "roles",
+}
diff --git a/src/backend/persistence/persistence-utils.ts b/src/backend/persistence/persistence-utils.ts
new file mode 100644
index 0000000..69f1060
--- /dev/null
+++ b/src/backend/persistence/persistence-utils.ts
@@ -0,0 +1,317 @@
+import {
+ IPersistenceJoin,
+ IPersistentOrderBy,
+ SimpleWhere,
+ WhereCondition,
+} from "./persistence-contracts";
+
+export const sql = String.raw;
+
+/**
+ * Builds a WHERE clause for SQL queries
+ * @param where Where condition or undefined
+ * @returns Object containing the WHERE clause and values array
+ */
+export const buildWhereClause = (
+ where: WhereCondition | undefined
+): { whereClause: string; values: any[] } => {
+ // If no where clause is provided, return empty
+ if (!where) {
+ return { whereClause: "", values: [] };
+ }
+
+ const values: any[] = [];
+
+ // Process the where condition
+ const result = processWhereCondition(where, values);
+
+ return {
+ whereClause: result,
+ values,
+ };
+};
+
+/**
+ * Process a where condition recursively
+ */
+const processWhereCondition = (
+ where: WhereCondition,
+ values: any[]
+): string => {
+ // Handle composite conditions (AND/OR)
+ if (typeof where === "object") {
+ if ("AND" in where && Array.isArray(where.AND) && where.AND.length > 0) {
+ const conditions = where.AND.map((condition) =>
+ processWhereCondition(condition, values)
+ ).filter(Boolean);
+
+ if (conditions.length === 0) return "";
+ if (conditions.length === 1) return conditions[0];
+
+ return `(${conditions.join(" AND ")})`;
+ }
+
+ if ("OR" in where && Array.isArray(where.OR) && where.OR.length > 0) {
+ const conditions = where.OR.map((condition) =>
+ processWhereCondition(condition, values)
+ ).filter(Boolean);
+
+ if (conditions.length === 0) return "";
+ if (conditions.length === 1) return conditions[0];
+
+ return `(${conditions.join(" OR ")})`;
+ }
+
+ // Handle simple conditions
+ if ("key" in where && "operator" in where) {
+ return processSimpleCondition(where as SimpleWhere, values);
+ }
+ }
+
+ return "";
+};
+
+/**
+ * Process a simple condition
+ */
+const processSimpleCondition = (
+ condition: SimpleWhere,
+ values: any[]
+): string => {
+ const { key, operator, value } = condition;
+
+ if (!key) return ""; // Skip if key is missing
+
+ // Handle arrays for IN and NOT IN operators
+ if ((operator === "in" || operator === "not in") && Array.isArray(value)) {
+ if (value.length === 0) {
+ return operator === "in" ? "FALSE" : "TRUE";
+ }
+
+ const placeholders = value
+ .map(() => `$${values.length + 1}`)
+ .map((placeholder, index) => {
+ values.push(value[index]);
+ return placeholder;
+ })
+ .join(", ");
+
+ return `"${key.toString()}" ${operator} (${placeholders})`;
+ }
+
+ // Handle NULL values
+ if (value === null) {
+ return operator === "="
+ ? `"${key.toString()}" IS NULL`
+ : operator === "<>"
+ ? `"${key.toString()}" IS NOT NULL`
+ : `"${key.toString()}" IS NULL`;
+ }
+
+ // Standard case with non-null value
+ values.push(value);
+ return `"${key.toString()}" ${operator} $${values.length}`;
+};
+
+/**
+ * Builds an ORDER BY clause for SQL queries
+ * @param orderBy Array of order specifications
+ * @returns Formatted ORDER BY clause
+ */
+export const buildOrderByClause = (
+ orderBy?: Array>
+): string => {
+ if (!orderBy || orderBy.length === 0) {
+ return ""; // No order by clause
+ }
+
+ const orderByConditions = orderBy.map(({ key, direction }) => {
+ // Convert column name to snake_case for database compatibility
+ const snakeCaseColumn = toSnakeCase(key.toString());
+
+ // Escape column name to prevent SQL injection
+ const safeColumn = `"${snakeCaseColumn}"`;
+
+ // Validate and normalize order direction
+ const safeDirection = direction?.toLowerCase() === "desc" ? "DESC" : "ASC";
+
+ // Add NULLS LAST for better sorting behavior
+ const nullsOrder = safeDirection === "DESC" ? "NULLS LAST" : "NULLS FIRST";
+
+ return `${safeColumn} ${safeDirection} ${nullsOrder}`;
+ });
+
+ return `ORDER BY ${orderByConditions.join(", ")}`;
+};
+
+export const buildJoinClause = (joins?: Array) => {
+ if (!joins || joins.length === 0) {
+ return {
+ joinConditionClause: "",
+ joinSelectClause: [],
+ };
+ }
+
+ const joinConditions = joins.map(({ joinTo, localField, foreignField }) => {
+ return `LEFT JOIN "${joinTo}" ON "${joinTo}"."${foreignField}" = "${localField}"`;
+ });
+
+ const joinSelectClause = joins.map(({ as, joinTo, columns }) => {
+ const jsonColumns = columns
+ ?.map((col) => `'${col}', ${joinTo}.${col}`)
+ .join(", ");
+
+ return `,json_build_object(${jsonColumns}) AS ${as}`;
+ });
+
+ return { joinConditionClause: joinConditions.join(" "), joinSelectClause };
+};
+
+/**
+ * Builds a safe SQL query with values embedded for debugging or logging purposes.
+ * WARNING: This is meant for debugging only. Never use this for actual query execution.
+ *
+ * @param sql The parameterized SQL query with $n placeholders
+ * @param values Array of values to replace the placeholders
+ * @returns SQL query with values safely embedded
+ */
+export function buildSafeQuery(sql: string, values: any[]): string {
+ if (!sql) return "";
+ if (!values || !values.length) return sql;
+
+ // Create a copy to avoid modifying the original SQL
+ let safeSql = sql;
+
+ // Replace $n placeholders with formatted values
+ safeSql = safeSql.replace(/\$(\d+)/g, (match, indexStr) => {
+ const index = parseInt(indexStr, 10) - 1;
+
+ // Check if the index is valid
+ if (index < 0 || index >= values.length) {
+ // Return the original placeholder if the index is out of bounds
+ return match;
+ }
+
+ const value = values[index];
+ return formatSqlValue(value);
+ });
+
+ return safeSql;
+}
+
+/**
+ * Formats a JavaScript value for safe inclusion in SQL.
+ * Handles various types including null, strings, numbers, booleans, dates, arrays, and objects.
+ *
+ * @param value The value to format for SQL
+ * @returns SQL-safe representation of the value
+ */
+export function formatSqlValue(value: any): string {
+ // Handle null and undefined
+ if (value === null || value === undefined) {
+ return "NULL";
+ }
+
+ // Handle numbers
+ if (typeof value === "number") {
+ // Handle NaN and Infinity
+ if (isNaN(value)) return "NULL";
+ if (!isFinite(value)) return "NULL";
+ return value.toString();
+ }
+
+ // Handle booleans
+ if (typeof value === "boolean") {
+ return value ? "TRUE" : "FALSE";
+ }
+
+ // Handle dates
+ if (value instanceof Date) {
+ // Format to ISO string and ensure proper SQL timestamp format
+ return `'${value
+ .toISOString()
+ .replace("T", " ")
+ .replace("Z", "")}'::timestamp`;
+ }
+
+ // Handle strings
+ if (typeof value === "string") {
+ // Escape single quotes by doubling them (SQL standard)
+ const escaped = value.replace(/'/g, "''");
+ return `'${escaped}'`;
+ }
+
+ // Handle arrays
+ if (Array.isArray(value)) {
+ if (value.length === 0) {
+ return `'{}'`;
+ }
+
+ // Format each array element and join with commas
+ const formattedElements = value.map((element) => formatSqlValue(element));
+ return `ARRAY[${formattedElements.join(",")}]`;
+ }
+
+ // Handle objects (convert to JSONB)
+ if (typeof value === "object") {
+ try {
+ // Safely stringify the object and escape any single quotes
+ const jsonStr = JSON.stringify(value).replace(/'/g, "''");
+ return `'${jsonStr}'::jsonb`;
+ } catch (error) {
+ // Fallback if JSON stringification fails
+ console.error("Error converting object to JSON:", error);
+ return "NULL";
+ }
+ }
+
+ // Default case - try to convert to string
+ try {
+ return `'${String(value).replace(/'/g, "''")}'`;
+ } catch (error) {
+ return "NULL";
+ }
+}
+
+/**
+ * Builds a SET clause for UPDATE SQL statements with proper type handling
+ * @param data Object containing field:value pairs to update
+ * @param startValues Initial values array for parameterized query
+ * @returns Object containing the SET clause and updated values array
+ */
+export const buildSetClause = (
+ data: Partial,
+ startValues: any[] = []
+): { setClause: string; values: any[] } => {
+ if (!data || Object.keys(data).length === 0) {
+ return { setClause: "", values: startValues };
+ }
+
+ const values = [...startValues];
+ const setClauses: string[] = [];
+
+ Object.entries(data).forEach(([key, value]) => {
+ // Convert key to snake_case for database compatibility
+ const snakeCaseKey = toSnakeCase(key);
+
+ // Use parameterized queries for values
+ const paramIndex = values.length + 1;
+ setClauses.push(`"${snakeCaseKey}" = $${paramIndex}`);
+ values.push(value);
+ });
+
+ return {
+ setClause: setClauses.join(", "),
+ values,
+ };
+};
+
+// Helper function to convert camelCase to snake_case
+export function toSnakeCase(str: string): string {
+ // return str
+ // ?.replace(/([A-Z])/g, "_$1")
+ // ?.replace(/^_/, "")
+ // ?.toLowerCase();
+
+ return str;
+}
diff --git a/src/backend/persistence/persistence-where-operator.ts b/src/backend/persistence/persistence-where-operator.ts
new file mode 100644
index 0000000..cbc6690
--- /dev/null
+++ b/src/backend/persistence/persistence-where-operator.ts
@@ -0,0 +1,203 @@
+/**
+ * Drizzle-style operator functions with direct generic approach
+ */
+
+import { IPersistenceJoin } from "./persistence-contracts";
+
+// Type for all possible operators
+type Operator =
+ | "="
+ | "<"
+ | ">"
+ | "<="
+ | ">="
+ | "<>"
+ | "like"
+ | "ilike"
+ | "in"
+ | "not in";
+
+// Base type for conditions
+export interface SimpleWhere {
+ key: keyof T;
+ operator: Operator;
+ value: any;
+}
+
+// Type for composite conditions
+export interface CompositeWhere {
+ AND?: Array>;
+ OR?: Array>;
+}
+
+// Union type for any condition
+export type WhereCondition = SimpleWhere | CompositeWhere;
+
+// Equal
+export function eq(key: K, value: T[K]): SimpleWhere {
+ return {
+ key,
+ operator: "=",
+ value,
+ };
+}
+
+// Not equal
+export function neq(key: K, value: T[K]): SimpleWhere {
+ return {
+ key,
+ operator: "<>",
+ value,
+ };
+}
+
+// Greater than
+export function gt(key: K, value: T[K]): SimpleWhere {
+ return {
+ key,
+ operator: ">",
+ value,
+ };
+}
+
+// Greater than or equal
+export function gte(key: K, value: T[K]): SimpleWhere {
+ return {
+ key,
+ operator: ">=",
+ value,
+ };
+}
+
+// Less than
+export function lt(key: K, value: T[K]): SimpleWhere {
+ return {
+ key,
+ operator: "<",
+ value,
+ };
+}
+
+// Less than or equal
+export function lte(key: K, value: T[K]): SimpleWhere {
+ return {
+ key,
+ operator: "<=",
+ value,
+ };
+}
+
+// Like (case-sensitive)
+export function like(key: keyof T, pattern: string): SimpleWhere {
+ return {
+ key,
+ operator: "like",
+ value: pattern,
+ };
+}
+
+// ILike (case-insensitive)
+export function ilike(key: keyof T, pattern: string): SimpleWhere {
+ return {
+ key,
+ operator: "ilike",
+ value: pattern,
+ };
+}
+
+// In list of values
+export function inArray(
+ key: K,
+ values: T[K][]
+): SimpleWhere {
+ return {
+ key,
+ operator: "in",
+ value: values,
+ };
+}
+
+// Not in list of values
+export function notInArray(
+ key: K,
+ values: T[K][]
+): SimpleWhere {
+ return {
+ key,
+ operator: "not in",
+ value: values,
+ };
+}
+
+// Is null
+export function isNull(key: keyof T): SimpleWhere {
+ return {
+ key,
+ operator: "=",
+ value: null,
+ };
+}
+
+// Is not null
+export function isNotNull(key: keyof T): SimpleWhere {
+ return {
+ key,
+ operator: "<>",
+ value: null,
+ };
+}
+
+// Logical AND
+export function and(
+ ...conditions: Array>
+): CompositeWhere {
+ return {
+ AND: conditions,
+ };
+}
+
+// Logical OR
+export function or(
+ ...conditions: Array>
+): CompositeWhere {
+ return {
+ OR: conditions,
+ };
+}
+
+// Types for orderBy
+export interface IPersistentOrderBy {
+ key: keyof T;
+ direction: "asc" | "desc";
+}
+
+// Sorting helpers
+export function asc(key: keyof T): IPersistentOrderBy {
+ return {
+ key,
+ direction: "asc",
+ };
+}
+
+export function desc(key: keyof T): IPersistentOrderBy {
+ return {
+ key,
+ direction: "desc",
+ };
+}
+
+export function joinTable(payload: {
+ as: string;
+ joinTo: string;
+ localField: keyof T;
+ foreignField: keyof U;
+ columns: Array;
+}): IPersistenceJoin {
+ return {
+ as: payload.as,
+ joinTo: payload.joinTo,
+ localField: payload.localField.toString(),
+ foreignField: payload.foreignField.toString(),
+ columns: payload.columns.map((col) => col.toString()),
+ };
+}
diff --git a/src/backend/persistence/persistence.repository.ts b/src/backend/persistence/persistence.repository.ts
new file mode 100644
index 0000000..f80b582
--- /dev/null
+++ b/src/backend/persistence/persistence.repository.ts
@@ -0,0 +1,238 @@
+import { log } from "console";
+import {
+ AppPaginationResponseDto,
+ IPagination,
+ IPersistentDriver,
+ IPersistentPaginationPayload,
+ IPersistentQueryPayload,
+ IPersistentUpdatePayload,
+} from "./persistence-contracts";
+import {
+ buildJoinClause,
+ buildOrderByClause,
+ buildSetClause,
+ buildWhereClause,
+ toSnakeCase,
+} from "./persistence-utils";
+import { removeNullOrUndefinedFromObject } from "@/lib/utils";
+
+export class PersistentRepository {
+ constructor(
+ public readonly tableName: string,
+ public readonly persistentDriver: IPersistentDriver
+ ) {}
+
+ async findAllWithPagination(
+ payload: IPagination
+ ): Promise> {
+ const _limit = payload.limit || 10;
+ const _page = payload.page || 1;
+ const _offset = (_page - 1) * _limit;
+
+ // Execute the main query
+ const nodes = await this.findRows({
+ limit: _limit,
+ offset: _offset,
+ columns: payload?.columns || [],
+ where: payload?.where || undefined,
+ orderBy: payload?.orderBy || [],
+ joins: payload?.joins || [],
+ });
+
+ // Execute the count query
+ const totalCountResult =
+ (await this.findRowCount({
+ where: payload?.where || undefined,
+ })) || 0;
+
+ return {
+ nodes: nodes as DOMAIN_MODEL_TYPE[],
+ meta: {
+ totalCount: +totalCountResult,
+ currentPage: +_page,
+ hasNextPage: _page * _limit < totalCountResult,
+ totalPages: +Math.ceil(totalCountResult / _limit),
+ },
+ };
+ }
+
+ /**
+ * Finds rows in the database based on the provided where conditions.
+ * @param payload
+ */
+ async findRows(payload: IPersistentPaginationPayload) {
+ // Default columns to '*' if none are provided
+ const columns =
+ payload.columns
+ ?.map((col) => `${this.tableName}.${col.toString()}`)
+ .join(",") ?? "*";
+ const { whereClause, values } = buildWhereClause(payload.where);
+ const orderByClause = buildOrderByClause(payload?.orderBy);
+ const { joinConditionClause, joinSelectClause } = buildJoinClause(
+ payload.joins
+ );
+
+ // Build the SQL query with LIMIT, OFFSET, and ORDER BY
+ const limit = payload.limit == -1 ? undefined : payload.limit; // Default limit to 10 if not provided
+ const offset = payload.offset ?? 0; // Default offset to 0 if not provided
+
+ const sqlQuery = `
+ SELECT ${columns}
+ ${joinSelectClause ? `${joinSelectClause.join(",")}` : ""}
+ FROM ${this.tableName}
+ ${joinConditionClause ? joinConditionClause : ""}
+ ${whereClause ? `WHERE ${whereClause}` : ""}
+ ${orderByClause ? orderByClause : ""}
+ ${limit ? `LIMIT ${limit}` : ""} ${offset ? `OFFSET ${offset}` : ""};
+ `;
+
+ // Execute the SQL query
+ const result = await this.persistentDriver.executeSQL(sqlQuery, values);
+ return result.rows as DOMAIN_MODEL_TYPE[];
+ }
+
+ /**
+ * Finds the count of rows in the database based on the provided where conditions.
+ * @param payload
+ */
+ async findRowCount(
+ payload: IPersistentPaginationPayload
+ ): Promise {
+ const { whereClause, values } = buildWhereClause(payload.where);
+
+ // Construct the SQL query
+ const query = `
+ SELECT COUNT(*) as count
+ FROM ${this.tableName}
+ ${whereClause ? `WHERE ${whereClause}` : ""};
+ `;
+
+ const result = await this.persistentDriver.executeSQL(query, values);
+ return parseInt(result.rows[0].count, 10);
+ }
+
+ /**
+ * Creates a new record in the database.
+ *
+ * @param data - The data to be inserted.
+ * @returns The newly created record.
+ */
+ async createOne(
+ data: Partial
+ ): Promise {
+ // Prepare columns and placeholders for the insert statement
+ function toSnakeCase(str: string): string {
+ return str
+ .replace(/([A-Z])/g, "_$1")
+ .replace(/^_/, "")
+ .toLowerCase();
+ }
+
+ const columns = Object.keys(data).map(toSnakeCase).join(", ");
+
+ const placeholders = Object.keys(data)
+ .map((_, index) => `$${index + 1}`)
+ .join(", ");
+ const values = Object.values(data) as any[];
+
+ // Build the SQL query
+ const sql = `
+ INSERT INTO ${this.tableName} (${columns},created_at,updated_at)
+ VALUES (${placeholders}, now(), now())
+ RETURNING *;
+ `;
+
+ // Execute the SQL query
+ const result = await this.executeSQL(sql, values);
+ return result.rows[0] as DOMAIN_MODEL_TYPE;
+ }
+
+ /**
+ * Creates multiple records in the database.
+ *
+ * @param payload
+ */
+ async createMany(
+ payload: Partial[]
+ ): Promise {
+ const results = [];
+
+ for (const data of payload) {
+ results.push(await this.createOne(data));
+ }
+ return results as DOMAIN_MODEL_TYPE[];
+ }
+
+ /**
+ * Updates a record in the database based on where conditions.
+ * @param payload Query conditions
+ */
+ async updateOne(
+ payload: IPersistentUpdatePayload
+ ): Promise {
+ // Build WHERE clause
+ const { whereClause, values: whereValues } = buildWhereClause(
+ payload.where
+ );
+
+ // Build SET clause using the where values as starting point
+ const { setClause, values: allValues } = buildSetClause(
+ removeNullOrUndefinedFromObject(payload.data),
+ whereValues
+ );
+
+ // Handle columns for RETURNING
+ const columns = toSnakeCase((payload.columns as any) || ["*"]);
+
+ // Build final SQL query
+ const sql = `
+ UPDATE ${this.tableName}
+ ${setClause ? `SET ${setClause}` : ""},"updated_at" = now()
+ ${whereClause ? `WHERE ${whereClause}` : ""}
+ RETURNING ${columns};
+ `;
+
+ // Execute the SQL query
+ const result = await this.persistentDriver.executeSQL(sql, allValues);
+
+ if (!result.rows || result.rows.length === 0) {
+ throw new Error(`No record found to update with the given conditions`);
+ }
+
+ return result.rows[0] as DOMAIN_MODEL_TYPE;
+ }
+
+ /**
+ * Deletes rows in the database based on the provided where conditions.
+ * @param payload
+ */
+ async deleteRows(
+ payload: IPersistentQueryPayload
+ ): Promise {
+ const { whereClause, values } = buildWhereClause(payload.where);
+ const columns = toSnakeCase(payload.columns as any) || "*";
+
+ const sql = `
+ DELETE
+ FROM ${this.tableName} ${
+ whereClause ? `WHERE ${whereClause}` : ""
+ } RETURNING ${columns};
+ `;
+
+ const result = await this.executeSQL(sql, values);
+ return result.rows as DOMAIN_MODEL_TYPE[];
+ }
+
+ /**
+ * Executes a raw SQL query with the provided values.
+ * @param sql
+ * @param values
+ */
+ executeSQL(sql: string, values: string[]) {
+ try {
+ return this.persistentDriver.executeSQL(sql, values);
+ } catch (e) {
+ throw new Error("Error in executeSQL");
+ }
+ }
+}
diff --git a/src/backend/schemas/schemas.ts b/src/backend/schemas/schemas.ts
new file mode 100644
index 0000000..10c93c5
--- /dev/null
+++ b/src/backend/schemas/schemas.ts
@@ -0,0 +1,123 @@
+import {
+ AnyPgColumn,
+ boolean,
+ json,
+ jsonb,
+ pgTable,
+ serial,
+ text,
+ timestamp,
+ uuid,
+ varchar,
+} from "drizzle-orm/pg-core";
+import { IServerFile } from "../models/domain-models";
+
+export const usersTable = pgTable("users", {
+ id: uuid("id").defaultRandom().primaryKey(),
+ name: varchar("name").notNull(),
+ username: varchar("username").notNull(),
+ email: varchar("email"),
+ profile_photo: varchar("profile_photo"),
+ education: varchar("education"),
+ designation: varchar("designation"),
+ bio: varchar("bio"),
+ websiteUrl: varchar("website_url"),
+ location: varchar("location"),
+ social_links: json("social_links"),
+ profile_readme: text("profile_readme"),
+ skills: varchar("skills"),
+ created_at: timestamp("created_at"),
+ updated_at: timestamp("updated_at"),
+});
+
+export const userSocialsTable = pgTable("user_socials", {
+ id: serial("id").primaryKey(),
+ service: varchar("service").notNull(),
+ service_uid: varchar("service_uid").notNull(),
+ user_id: uuid("user_id")
+ .notNull()
+ .references(() => usersTable.id, { onDelete: "cascade" }),
+ created_at: timestamp("created_at"),
+ updated_at: timestamp("updated_at"),
+});
+
+export const userSessionsTable = pgTable("user_sessions", {
+ id: uuid("id").defaultRandom().primaryKey(),
+ user_id: uuid("user_id")
+ .notNull()
+ .references(() => usersTable.id, { onDelete: "cascade" }),
+ token: varchar("token").notNull(),
+ device: varchar("device"), // os + browser
+ ip: varchar("ip"),
+ last_action_at: timestamp("last_action_at"),
+ created_at: timestamp("created_at"),
+ updated_at: timestamp("updated_at"),
+});
+
+export const userFollowsTable = pgTable("user_follows", {
+ id: serial("id").primaryKey(),
+ follower_id: uuid("follower_id")
+ .notNull()
+ .references(() => usersTable.id, { onDelete: "cascade" }),
+ followee_id: uuid("followee_id")
+ .notNull()
+ .references(() => usersTable.id, { onDelete: "cascade" }),
+ created_at: timestamp("created_at"),
+ updated_at: timestamp("updated_at"),
+});
+
+export const articlesTable = pgTable("articles", {
+ id: uuid("id").defaultRandom().primaryKey(),
+ title: varchar("title").notNull(),
+ handle: varchar("handle").notNull(),
+ excerpt: varchar("excerpt"),
+ body: text("body"),
+ cover_image: jsonb("cover_image").$type(),
+ is_published: boolean("is_published").default(false),
+ published_at: timestamp("published_at"),
+ approved_at: timestamp("approved_at"),
+ metadata: jsonb("metadata"),
+ author_id: uuid("author_id")
+ .notNull()
+ .references(() => usersTable.id, { onDelete: "cascade" }),
+ created_at: timestamp("created_at"),
+ updated_at: timestamp("updated_at"),
+});
+
+export const commentsTable = pgTable("comments", {
+ id: uuid("id").defaultRandom().primaryKey(),
+ body: text("body").notNull(),
+ commentable_type: varchar("commentable_type").notNull(),
+ commentable_id: uuid("commentable_id").notNull(),
+ user_id: uuid("user_id")
+ .notNull()
+ .references(() => usersTable.id, { onDelete: "cascade" }),
+ parent_id: uuid("parent_id").references((): AnyPgColumn => commentsTable.id, {
+ onDelete: "cascade",
+ }),
+ created_at: timestamp("created_at").defaultNow(),
+ updated_at: timestamp("updated_at").defaultNow(),
+});
+
+export const tags = pgTable("tags", {
+ id: uuid("id").defaultRandom().primaryKey(),
+ name: varchar("name", { length: 50 }).notNull(),
+ icon: jsonb("icon").$type(),
+ color: varchar("color", { length: 6 }),
+ description: text("description"),
+ created_at: timestamp("created_at"),
+ updated_at: timestamp("updated_at"),
+});
+
+export const articleTagsTable = pgTable("article_tag", {
+ id: serial("id").primaryKey(),
+ article_id: uuid("article_id")
+ .notNull()
+ .references(() => articlesTable.id, { onDelete: "cascade" }),
+ tag_id: uuid("tag_id")
+ .notNull()
+ .references(() => tags.id, { onDelete: "cascade" }),
+
+ created_at: timestamp("created_at"),
+ updated_at: timestamp("updated_at"),
+});
diff --git a/src/backend/services/RepositoryException.ts b/src/backend/services/RepositoryException.ts
new file mode 100644
index 0000000..d08274e
--- /dev/null
+++ b/src/backend/services/RepositoryException.ts
@@ -0,0 +1,27 @@
+import { zodErrorToString } from "@/lib/utils";
+import { z } from "zod";
+
+export class RepositoryException extends Error {
+ constructor(message?: string, options?: ErrorOptions) {
+ super(message, options);
+ this.message = message ?? "Validation error";
+ }
+
+ toString(): string {
+ return this.message;
+ }
+}
+
+export const handleRepositoryException = (error: any) => {
+ if (error instanceof RepositoryException) {
+ return error.toString();
+ }
+
+ if (error instanceof Error) {
+ return error.message;
+ }
+
+ if (error instanceof z.ZodError) {
+ throw new RepositoryException(zodErrorToString(error));
+ }
+};
diff --git a/src/backend/services/action-type.ts b/src/backend/services/action-type.ts
new file mode 100644
index 0000000..057a542
--- /dev/null
+++ b/src/backend/services/action-type.ts
@@ -0,0 +1,23 @@
+export enum USER_SESSION_KEY {
+ SESSION_TOKEN = "session_token",
+ SESSION_USER_ID = "session_userId",
+}
+
+export interface ISession {
+ id: string;
+ user_id: string;
+ token: string;
+ device?: string;
+}
+
+export interface ISessionUser {
+ id: string;
+ name: string;
+ username: string;
+ email: string;
+ profile_photo: string;
+}
+
+export type SessionResult =
+ | { session: ISession; user: ISessionUser }
+ | { session: null; user: null };
diff --git a/src/backend/services/article.actions.ts b/src/backend/services/article.actions.ts
new file mode 100644
index 0000000..d7f7c54
--- /dev/null
+++ b/src/backend/services/article.actions.ts
@@ -0,0 +1,449 @@
+"use server";
+
+import { generateRandomString, removeMarkdownSyntax } from "@/lib/utils";
+import { z } from "zod";
+import { Article, User } from "../models/domain-models";
+import { pgClient } from "../persistence/database-drivers/pg.client";
+import {
+ and,
+ desc,
+ eq,
+ joinTable,
+ neq,
+} from "../persistence/persistence-where-operator";
+import { PersistentRepository } from "../persistence/persistence.repository";
+import {
+ handleRepositoryException,
+ RepositoryException,
+} from "./RepositoryException";
+import { ArticleRepositoryInput } from "./inputs/article.input";
+import { getSessionUserId } from "./session.actions";
+import { slugify } from "@/lib/slug-helper.util";
+
+const articleRepository = new PersistentRepository(
+ "articles",
+ pgClient
+);
+
+/**
+ * Creates a new article in the database.
+ *
+ * @param _input - The article data to create, validated against ArticleRepositoryInput.createArticleInput schema
+ * @returns Promise - The newly created article
+ * @throws {RepositoryException} If article creation fails or validation fails
+ */
+export async function createArticle(
+ _input: z.infer
+) {
+ try {
+ const input =
+ await ArticleRepositoryInput.createArticleInput.parseAsync(_input);
+ const article = await articleRepository.createOne({
+ title: input.title,
+ handle: input.handle,
+ excerpt: input.excerpt ?? null,
+ body: input.body ?? null,
+ cover_image: input.cover_image ?? null,
+ is_published: input.is_published ?? false,
+ published_at: input.is_published ? new Date() : null,
+ author_id: input.author_id,
+ });
+ return article;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+export async function createMyArticle(
+ _input: z.infer
+) {
+ try {
+ const sessionUserId = await getSessionUserId();
+ if (!sessionUserId) {
+ throw new RepositoryException("Unauthorized");
+ }
+
+ const input =
+ await ArticleRepositoryInput.createMyArticleInput.parseAsync(_input);
+
+ const handle = await getUniqueArticleHandle(input.title);
+
+ const article = await articleRepository.createOne({
+ title: input.title,
+ handle: handle,
+ excerpt: input.excerpt ?? null,
+ body: input.body ?? null,
+ cover_image: input.cover_image ?? null,
+ is_published: input.is_published ?? false,
+ published_at: input.is_published ? new Date() : null,
+ author_id: sessionUserId,
+ });
+ return article;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+export const getUniqueArticleHandle = async (title: string) => {
+ try {
+ const count = await articleRepository.findRowCount({
+ where: eq("handle", slugify(title)),
+ columns: ["id", "handle"],
+ });
+ if (count) {
+ return `${slugify(title)}-${count + 1}`;
+ }
+ return slugify(title);
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+};
+
+/**
+ * Updates an existing article in the database.
+ *
+ * @param _input - The article update data, validated against ArticleRepositoryInput.updateArticleInput schema
+ * @returns Promise - The updated article
+ * @throws {RepositoryException} If article update fails, article not found, or validation fails
+ */
+export async function updateArticle(
+ _input: z.infer
+) {
+ try {
+ const input =
+ await ArticleRepositoryInput.updateArticleInput.parseAsync(_input);
+ const article = await articleRepository.updateOne({
+ where: eq("id", input.article_id),
+ data: {
+ title: input.title,
+ handle: input.handle,
+ excerpt: input.excerpt,
+ body: input.body,
+ cover_image: input.cover_image,
+ is_published: input.is_published,
+ published_at: input.is_published ? new Date() : null,
+ },
+ });
+ return article;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+export async function updateMyArticle(
+ _input: z.infer
+) {
+ try {
+ const sessionUserId = await getSessionUserId();
+ if (!sessionUserId) {
+ throw new RepositoryException("Unauthorized");
+ }
+
+ const input =
+ await ArticleRepositoryInput.updateMyArticleInput.parseAsync(_input);
+ const article = await articleRepository.updateOne({
+ where: and(eq("id", input.article_id), eq("author_id", sessionUserId)),
+ data: {
+ title: input.title,
+ handle: input.handle,
+ excerpt: input.excerpt,
+ body: input.body,
+ cover_image: input.cover_image,
+ is_published: input.is_published,
+ published_at: input.is_published ? new Date() : null,
+ },
+ });
+ return article;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+/**
+ * Deletes an article from the database.
+ *
+ * @param article_id - The unique identifier of the article to delete
+ * @returns Promise - The deleted article
+ * @throws {RepositoryException} If article deletion fails or article not found
+ */
+export async function deleteArticle(article_id: string) {
+ try {
+ const deletedArticles = await articleRepository.deleteRows({
+ where: eq("id", article_id),
+ });
+
+ if (!deletedArticles || deletedArticles.length === 0) {
+ throw new RepositoryException(
+ "Article not found or could not be deleted"
+ );
+ }
+
+ return deletedArticles[0];
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+/**
+ * Retrieves the most recent published articles.
+ *
+ * @param limit - Maximum number of articles to return (default: 5)
+ * @returns Promise - Array of recent articles with author information
+ * @throws {RepositoryException} If query fails
+ */
+export async function findRecentArticles(
+ limit: number = 5
+): Promise {
+ try {
+ return articleRepository.findRows({
+ where: and(eq("is_published", true), neq("published_at", null)),
+ limit,
+ orderBy: [desc("published_at")],
+ columns: ["id", "title", "handle"],
+ joins: [
+ joinTable({
+ as: "user",
+ joinTo: "users",
+ localField: "author_id",
+ foreignField: "id",
+ columns: ["id", "name", "username", "profile_photo"],
+ }),
+ ],
+ });
+ } catch (error) {
+ handleRepositoryException(error);
+ return [];
+ }
+}
+
+/**
+ * Retrieves a paginated feed of published articles.
+ *
+ * @param _input - Feed parameters including page and limit, validated against ArticleRepositoryInput.feedInput schema
+ * @returns Promise<{ data: Article[], total: number }> - Paginated articles with total count
+ * @throws {RepositoryException} If query fails or validation fails
+ */
+export async function articleFeed(
+ _input: z.infer
+) {
+ try {
+ const input = await ArticleRepositoryInput.feedInput.parseAsync(_input);
+
+ const response = await articleRepository.findAllWithPagination({
+ where: and(eq("is_published", true), neq("approved_at", null)),
+ page: input.page,
+ limit: input.limit,
+ orderBy: [desc("published_at")],
+ columns: [
+ "id",
+ "title",
+ "handle",
+ "cover_image",
+ "body",
+ "created_at",
+ "excerpt",
+ ],
+ joins: [
+ joinTable({
+ as: "user",
+ joinTo: "users",
+ localField: "author_id",
+ foreignField: "id",
+ columns: ["id", "name", "username", "profile_photo"],
+ }),
+ ],
+ });
+
+ response["nodes"] = response["nodes"].map((article) => {
+ return {
+ ...article,
+ excerpt: article.excerpt ?? removeMarkdownSyntax(article.body),
+ };
+ });
+
+ return response;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+export async function userArticleFeed(
+ _input: z.infer,
+ columns?: (keyof Article)[]
+) {
+ try {
+ const input = await ArticleRepositoryInput.userFeedInput.parseAsync(_input);
+
+ const response = await articleRepository.findAllWithPagination({
+ where: and(
+ eq("is_published", true),
+ neq("approved_at", null),
+ eq("author_id", input.user_id)
+ ),
+ page: input.page,
+ limit: input.limit,
+ orderBy: [desc("published_at")],
+ columns: columns ?? [
+ "id",
+ "title",
+ "handle",
+ "cover_image",
+ "body",
+ "created_at",
+ "excerpt",
+ ],
+ joins: [
+ joinTable({
+ as: "user",
+ joinTo: "users",
+ localField: "author_id",
+ foreignField: "id",
+ columns: ["id", "name", "username", "profile_photo"],
+ }),
+ ],
+ });
+
+ response["nodes"] = response["nodes"].map((article) => {
+ return {
+ ...article,
+ excerpt: article.excerpt ?? removeMarkdownSyntax(article.body),
+ };
+ });
+
+ return response;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+export async function articleDetailByHandle(article_handle: string) {
+ try {
+ const [article] = await articleRepository.findRows({
+ where: eq("handle", article_handle),
+ columns: [
+ "id",
+ "title",
+ "handle",
+ "excerpt",
+ "body",
+ "cover_image",
+ "is_published",
+ "published_at",
+ "approved_at",
+ "metadata",
+ "author_id",
+ "created_at",
+ "updated_at",
+ ],
+ joins: [
+ joinTable({
+ as: "user",
+ joinTo: "users",
+ localField: "author_id",
+ foreignField: "id",
+ columns: ["id", "name", "username", "profile_photo"],
+ }),
+ ],
+ limit: 1,
+ });
+
+ if (!article) {
+ throw new RepositoryException("Article not found");
+ }
+
+ return article;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+export async function articleDetailByUUID(uuid: string) {
+ try {
+ const [article] = await articleRepository.findRows({
+ where: eq("id", uuid),
+ columns: [
+ "id",
+ "title",
+ "handle",
+ "excerpt",
+ "body",
+ "cover_image",
+ "is_published",
+ "published_at",
+ "approved_at",
+ "metadata",
+ "author_id",
+ "created_at",
+ "updated_at",
+ ],
+ joins: [
+ joinTable({
+ as: "user",
+ joinTo: "users",
+ localField: "author_id",
+ foreignField: "id",
+ columns: ["id", "name", "username", "profile_photo"],
+ }),
+ ],
+ limit: 1,
+ });
+
+ if (!article) {
+ throw new RepositoryException("Article not found");
+ }
+
+ return article;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+export async function myArticles(
+ input: z.infer
+) {
+ const sessionUserId = await getSessionUserId();
+ try {
+ const articles = await articleRepository.findAllWithPagination({
+ where: eq("author_id", sessionUserId),
+ columns: [
+ "id",
+ "title",
+ "handle",
+ "created_at",
+ "is_published",
+ "approved_at",
+ ],
+ limit: input.limit,
+ page: input.page,
+ orderBy: [desc("created_at")],
+ });
+ return articles;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+/**
+ * Updates the status of an article.
+ * @param article_id - The unique identifier of the article to update
+ * @param is_published - The new status of the article
+ * @returns
+ */
+export async function setArticlePublished(
+ article_id: string,
+ is_published: boolean
+) {
+ const sessionUserId = await getSessionUserId();
+ try {
+ const articles = await articleRepository.updateOne({
+ where: and(eq("id", article_id), eq("author_id", sessionUserId)),
+ data: {
+ is_published: is_published,
+ published_at: is_published ? new Date() : null,
+ },
+ });
+ return articles;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
diff --git a/src/backend/services/dashboard.action.ts b/src/backend/services/dashboard.action.ts
new file mode 100644
index 0000000..08fc88a
--- /dev/null
+++ b/src/backend/services/dashboard.action.ts
@@ -0,0 +1,33 @@
+"use server";
+
+import * as sessionActions from "@/backend/services/session.actions";
+import { persistenceRepository } from "../persistence-repositories";
+import { sql } from "../persistence/persistence-utils";
+
+const query = sql`
+SELECT (SELECT Count(*)
+ FROM articles
+ WHERE author_id = $1)
+ AS total_articles,
+ (SELECT Count(*)
+ FROM comments
+ WHERE comments.commentable_type = 'ARTICLE'
+ AND comments.commentable_id IN (SELECT id
+ FROM articles
+ WHERE articles.author_id = $1))
+ AS total_comments
+`;
+
+export async function myArticleMatrix() {
+ const sessionUserId = await sessionActions.getSessionUserId();
+
+ const totalPostsQuery = await persistenceRepository.article.executeSQL(
+ query,
+ [sessionUserId!]
+ );
+
+ return {
+ total_articles: totalPostsQuery.rows[0].total_articles,
+ total_comments: totalPostsQuery.rows[0].total_comments,
+ };
+}
diff --git a/src/backend/services/inputs/article.input.ts b/src/backend/services/inputs/article.input.ts
new file mode 100644
index 0000000..5f0dd4d
--- /dev/null
+++ b/src/backend/services/inputs/article.input.ts
@@ -0,0 +1,107 @@
+import { z } from "zod";
+
+export const ArticleRepositoryInput = {
+ createArticleInput: z.object({
+ title: z.string(),
+ handle: z.string(),
+ excerpt: z.string().optional().nullable(),
+ body: z.string().optional().nullable(),
+ cover_image: z
+ .object({
+ key: z.string(),
+ provider: z.enum(["cloudinary", "direct"]),
+ })
+ .optional()
+ .nullable(),
+ is_published: z.boolean().optional().nullable(),
+ author_id: z.string(),
+ }),
+
+ createMyArticleInput: z.object({
+ title: z.string(),
+ excerpt: z.string().optional().nullable(),
+ body: z.string().optional().nullable(),
+ cover_image: z
+ .object({
+ key: z.string(),
+ provider: z.enum(["cloudinary", "direct"]),
+ })
+ .optional()
+ .nullable(),
+ is_published: z.boolean().optional().nullable(),
+ }),
+
+ updateArticleInput: z.object({
+ article_id: z.string(),
+ title: z.string().optional(),
+ handle: z.string().optional(),
+ excerpt: z.string().optional(),
+ body: z.string().optional(),
+ cover_image: z
+ .object({
+ key: z.string(),
+ provider: z.enum(["cloudinary", "direct"]),
+ })
+ .optional(),
+ is_published: z.boolean().optional(),
+ }),
+ updateMyArticleInput: z.object({
+ article_id: z.string(),
+ title: z.string().optional(),
+ handle: z.string().optional(),
+ excerpt: z.string().optional(),
+ body: z.string().optional(),
+ cover_image: z
+ .object({
+ key: z.string(),
+ provider: z.enum(["cloudinary", "direct"]),
+ alt: z.string().optional(),
+ })
+ .optional(),
+ is_published: z.boolean().optional(),
+ metadata: z
+ .object({
+ seo: z
+ .object({
+ title: z.string().optional(),
+ description: z.string().optional(),
+ keywords: z.array(z.string()).optional(),
+ canonical_url: z.string().url().optional(),
+ })
+ .nullable()
+ .optional(),
+ })
+ .nullable()
+ .optional(),
+ }),
+
+ feedInput: z.object({
+ page: z.number().default(1),
+ limit: z.number().default(10),
+ }),
+
+ userFeedInput: z.object({
+ user_id: z.string(),
+ page: z.number().default(1),
+ limit: z.number().default(10),
+ }),
+
+ findArticlesByAuthorInput: z.object({
+ author_id: z.string(),
+ published_only: z.boolean().default(false),
+ page: z.number().default(1),
+ limit: z.number().default(10),
+ }),
+
+ searchArticlesInput: z.object({
+ search_term: z.string().optional(),
+ published_only: z.boolean().default(true),
+ page: z.number().default(1),
+ limit: z.number().default(10),
+ }),
+
+ myArticleInput: z.object({
+ page: z.number().default(1),
+ limit: z.number().default(10),
+ }),
+};
diff --git a/src/backend/services/inputs/session.input.ts b/src/backend/services/inputs/session.input.ts
new file mode 100644
index 0000000..cf12919
--- /dev/null
+++ b/src/backend/services/inputs/session.input.ts
@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+export const UserSessionInput = {
+ createLoginSessionInput: z.object({
+ user_id: z.string(),
+ request: z.instanceof(Request),
+ }),
+};
diff --git a/src/backend/services/inputs/user.input.ts b/src/backend/services/inputs/user.input.ts
new file mode 100644
index 0000000..8bef8f0
--- /dev/null
+++ b/src/backend/services/inputs/user.input.ts
@@ -0,0 +1,28 @@
+import { z } from "zod";
+
+export const UserRepositoryInput = {
+ syncSocialUserInput: z.object({
+ service: z.enum(["github"]),
+ service_uid: z.string(),
+ name: z.string(),
+ username: z.string(),
+ email: z.string().email(),
+ profile_photo: z.string().url(),
+ bio: z.string().optional().nullable(),
+ }),
+ updateUserProfileInput: z.object({
+ id: z.string(),
+ name: z.string(),
+ username: z.string(),
+ email: z.string().email(),
+ profile_photo: z.string().url(),
+ education: z.string().optional(),
+ designation: z.string().optional(),
+ bio: z.string().optional(),
+ websiteUrl: z.string().url().optional(),
+ location: z.string().optional(),
+ social_links: z.record(z.string()).optional(),
+ profile_readme: z.string().optional(),
+ skills: z.string().optional(),
+ }),
+};
diff --git a/src/backend/services/oauth/GithubOAuthService.ts b/src/backend/services/oauth/GithubOAuthService.ts
new file mode 100644
index 0000000..21bc36c
--- /dev/null
+++ b/src/backend/services/oauth/GithubOAuthService.ts
@@ -0,0 +1,98 @@
+import { generateRandomString } from "@/lib/utils";
+import { IGithubUser, IOAuthService } from "./oauth-contract";
+import { cookies } from "next/headers";
+import { env } from "@/env";
+
+export class GithubOAuthService implements IOAuthService {
+ async getAuthorizationUrl(): Promise {
+ const state = generateRandomString(50);
+ const params = new URLSearchParams({
+ client_id: env.GITHUB_CLIENT_ID,
+ redirect_uri: env.GITHUB_CALLBACK_URL,
+ scope: "user:email",
+ state,
+ });
+ const _cookies = await cookies();
+ _cookies.set("github_oauth_state", state, {
+ path: "/",
+ secure: env.NODE_ENV === "production",
+ httpOnly: true,
+ maxAge: 60 * 10,
+ sameSite: "lax",
+ });
+ return `https://github.com/login/oauth/authorize?${params.toString()}`;
+ }
+
+ async getUserInfo(code: string, state: string): Promise {
+ const _cookies = await cookies();
+ const storedState = _cookies.get("github_oauth_state")?.value ?? null;
+
+ if (code === null || state === null || storedState === null) {
+ throw new Error("Please restart the process.");
+ }
+ if (state !== storedState) {
+ throw new Error("Please restart the process.");
+ }
+
+ const githubAccessToken = await validateGitHubCode(
+ code,
+ env.GITHUB_CLIENT_ID,
+ env.GITHUB_CLIENT_SECRET,
+ env.GITHUB_CALLBACK_URL
+ );
+
+ const githubUser = await getGithubUser(githubAccessToken.access_token);
+ return githubUser;
+ }
+}
+
+interface GitHubTokenResponse {
+ access_token: string;
+ token_type: string;
+ scope: string;
+}
+
+export const validateGitHubCode = async (
+ code: string,
+ clientId: string,
+ clientSecret: string,
+ redirectUri: string
+): Promise => {
+ const params = new URLSearchParams({
+ client_id: clientId,
+ client_secret: clientSecret,
+ code: code,
+ redirect_uri: redirectUri,
+ });
+
+ const response = await fetch(
+ `https://github.com/login/oauth/access_token?${params.toString()}`,
+ {
+ method: "POST",
+ headers: {
+ Accept: "application/json",
+ },
+ }
+ );
+
+ if (!response.ok) {
+ throw new Error("Failed to validate GitHub code");
+ }
+
+ const data = await response.json();
+ return data;
+};
+
+const getGithubUser = async (accessToken: string): Promise => {
+ const githubAPI = await fetch("https://api.github.com/user", {
+ headers: {
+ Authorization: `Bearer ${accessToken}`,
+ },
+ });
+ if (!githubAPI.ok) {
+ throw new Error("Failed to get GitHub user");
+ }
+
+ const githubUserResponse = (await githubAPI.json()) as IGithubUser;
+ return githubUserResponse;
+};
diff --git a/src/backend/services/oauth/oauth-contract.ts b/src/backend/services/oauth/oauth-contract.ts
new file mode 100644
index 0000000..5e9cba8
--- /dev/null
+++ b/src/backend/services/oauth/oauth-contract.ts
@@ -0,0 +1,41 @@
+export interface IOAuthService {
+ getAuthorizationUrl(state: string, clientId: string): Promise;
+ getUserInfo(code: string, state: string): Promise;
+}
+
+export interface IGithubUser {
+ login: string;
+ id: number;
+ node_id: string;
+ avatar_url: string;
+ gravatar_id: string;
+ url: string;
+ html_url: string;
+ followers_url: string;
+ following_url: string;
+ gists_url: string;
+ starred_url: string;
+ subscriptions_url: string;
+ organizations_url: string;
+ repos_url: string;
+ events_url: string;
+ received_events_url: string;
+ type: string;
+ user_view_type: string;
+ site_admin: boolean;
+ name: string;
+ company: string;
+ blog: string;
+ location: string;
+ email: string;
+ hireable: boolean;
+ bio: string;
+ twitter_username: string;
+ notification_email: string;
+ public_repos: number;
+ public_gists: number;
+ followers: number;
+ following: number;
+ created_at: Date;
+ updated_at: Date;
+}
diff --git a/src/backend/services/session.actions.ts b/src/backend/services/session.actions.ts
new file mode 100644
index 0000000..88e98bb
--- /dev/null
+++ b/src/backend/services/session.actions.ts
@@ -0,0 +1,196 @@
+"use server";
+
+import { generateRandomString } from "@/lib/utils";
+import { cookies } from "next/headers";
+import { userAgent } from "next/server";
+import { cache } from "react";
+import { z } from "zod";
+import { UserSession } from "../models/domain-models";
+import { persistenceRepository } from "../persistence-repositories";
+import { pgClient } from "../persistence/database-drivers/pg.client";
+import { eq } from "../persistence/persistence-where-operator";
+import { PersistentRepository } from "../persistence/persistence.repository";
+import { handleRepositoryException } from "./RepositoryException";
+import { SessionResult, USER_SESSION_KEY } from "./action-type";
+import { UserSessionInput } from "./inputs/session.input";
+import { env } from "@/env";
+
+const sessionRepository = new PersistentRepository(
+ "user_sessions",
+ pgClient
+);
+
+/**
+ * Creates a new login session for a user and sets a session cookie.
+ *
+ * @param _input - The session data containing user_id and request object, validated against UserSessionInput.createLoginSessionInput schema
+ * @returns Promise
+ * @throws {RepositoryException} If session creation fails or validation fails
+ */
+export async function createLoginSession(
+ _input: z.infer
+): Promise {
+ const _cookies = await cookies();
+ const token = generateRandomString(120);
+ try {
+ const input =
+ await UserSessionInput.createLoginSessionInput.parseAsync(_input);
+ const agent = userAgent(input.request);
+ await sessionRepository.createOne({
+ token,
+ user_id: input.user_id,
+ device: `${agent.os.name} ${agent.browser.name}`,
+ ip: input.request.headers.get("x-forwarded-for") ?? "",
+ last_action_at: new Date(),
+ });
+ _cookies.set(USER_SESSION_KEY.SESSION_TOKEN, token, {
+ path: "/",
+ secure: env.NODE_ENV === "production",
+ httpOnly: true,
+ maxAge: 60 * 60 * 24 * 30,
+ sameSite: "lax",
+ });
+ _cookies.set(USER_SESSION_KEY.SESSION_USER_ID, input.user_id, {
+ path: "/",
+ secure: env.NODE_ENV === "production",
+ httpOnly: true,
+ maxAge: 60 * 60 * 24 * 30,
+ sameSite: "lax",
+ });
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+export const validateSessionToken = async (
+ token: string
+): Promise => {
+ const [session] = await persistenceRepository.userSession.findRows({
+ limit: 1,
+ where: eq("token", token),
+ columns: ["id", "user_id", "token", "device"],
+ });
+ if (!session) {
+ return { session: null, user: null };
+ }
+
+ await persistenceRepository.userSession.updateOne({
+ where: eq("id", session.id),
+ data: {
+ last_action_at: new Date(),
+ },
+ });
+
+ const [user] = await persistenceRepository.user.findRows({
+ limit: 1,
+ where: eq("id", session.user_id),
+ columns: ["id", "name", "username", "email", "profile_photo"],
+ });
+
+ return {
+ session: {
+ id: session.id,
+ user_id: session.user_id,
+ token: session.token,
+ },
+ user: {
+ id: user?.id,
+ name: user?.name,
+ username: user?.username,
+ email: user?.email,
+ profile_photo: user?.profile_photo,
+ },
+ };
+};
+
+/**
+ * Get the current session.
+ * @returns - The current session.
+ */
+export const getSession = cache(async (): Promise => {
+ const _cookies = await cookies();
+ const token = _cookies.get(USER_SESSION_KEY.SESSION_TOKEN)?.value ?? null;
+ if (!token) {
+ return { session: null, user: null };
+ }
+ const result = await validateSessionToken(token);
+
+ if (!result) {
+ _cookies.delete(USER_SESSION_KEY.SESSION_TOKEN);
+ }
+
+ return result;
+});
+
+/**
+ * Get the current session user ID.
+ * @returns - The current session user ID.
+ */
+export const getSessionUserId = cache(async (): Promise => {
+ const _cookies = await cookies();
+ const userId = _cookies.get(USER_SESSION_KEY.SESSION_USER_ID)?.value ?? null;
+
+ if (!userId) {
+ throw new Error("Unauthorized");
+ }
+
+ return userId;
+});
+
+export const deleteLoginSession = async () => {
+ const _cookies = await cookies();
+ const token = _cookies.get(USER_SESSION_KEY.SESSION_TOKEN)?.value ?? null;
+ if (!token) {
+ return;
+ }
+
+ try {
+ await persistenceRepository.userSession.deleteRows({
+ where: eq("token", token),
+ });
+ } catch (error) {
+ } finally {
+ _cookies.delete(USER_SESSION_KEY.SESSION_TOKEN);
+ _cookies.delete(USER_SESSION_KEY.SESSION_USER_ID);
+ }
+};
+
+export const deleteSession = async (sessionId: string) => {
+ try {
+ await persistenceRepository.userSession.deleteRows({
+ where: eq("id", sessionId),
+ });
+ } catch (error) {}
+};
+
+export const mySessions = async () => {
+ const _cookies = await cookies();
+ const user_id = _cookies.get(USER_SESSION_KEY.SESSION_USER_ID)?.value ?? null;
+ if (!user_id) {
+ return [];
+ }
+
+ return persistenceRepository.userSession.findRows({
+ where: eq("user_id", user_id),
+ limit: -1,
+ });
+};
+
+/**
+ * Set the URL to redirect to after authentication.
+ * @param url - The URL to redirect to after authentication.
+ */
+export const setAfterAuthRedirect = async (url: string) => {
+ const _cookies = await cookies();
+ _cookies.set("next", url);
+};
+
+/**
+ * Get the URL to redirect to after authentication.
+ * @returns - The URL to redirect to after authentication.
+ */
+export const getAfterAuthRedirect = async () => {
+ const _cookies = await cookies();
+ const value = _cookies.get("next")?.value;
+ return value !== "null" ? value : null;
+};
diff --git a/src/backend/services/user.action.ts b/src/backend/services/user.action.ts
new file mode 100644
index 0000000..233664c
--- /dev/null
+++ b/src/backend/services/user.action.ts
@@ -0,0 +1,138 @@
+"use server";
+
+import { z } from "zod";
+import { User } from "../models/domain-models";
+import { persistenceRepository } from "../persistence-repositories";
+import { desc, eq } from "../persistence/persistence-where-operator";
+import { handleRepositoryException } from "./RepositoryException";
+import { UserRepositoryInput } from "./inputs/user.input";
+
+/**
+ * Updates a user's profile information.
+ *
+ * @param _input - The user profile data to update, validated against UserRepositoryInput.updateUserProfileInput schema
+ * @returns Promise - The updated user
+ * @throws {RepositoryException} If update fails or validation fails
+ */
+export async function updateUserProfile(
+ _input: z.infer
+) {
+ try {
+ const input =
+ await UserRepositoryInput.updateUserProfileInput.parseAsync(_input);
+
+ const updatedUser = await persistenceRepository.user.updateOne({
+ where: eq("id", input.id),
+ data: {
+ name: input.name,
+ username: input.username,
+ email: input.email,
+ profile_photo: input.profile_photo,
+ education: input.education,
+ designation: input.designation,
+ bio: input.bio,
+ website_url: input.websiteUrl,
+ location: input.location,
+ social_links: input.social_links,
+ profile_readme: input.profile_readme,
+ skills: input.skills,
+ },
+ });
+
+ return updatedUser;
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
+
+/**
+ * Retrieves a user by their ID.
+ *
+ * @param id - The user's ID
+ * @returns Promise - The user if found, null otherwise
+ * @throws {RepositoryException} If query fails
+ */
+export async function getUserById(id: string): Promise {
+ try {
+ const [user] = await persistenceRepository.user.findRows({
+ where: eq("id", id),
+ limit: 1,
+ });
+ return user;
+ } catch (error) {
+ handleRepositoryException(error);
+ return null;
+ }
+}
+
+/**
+ * Retrieves a user by their username.
+ *
+ * @param username - The user's username
+ * @returns Promise - The user if found, null otherwise
+ * @throws {RepositoryException} If query fails
+ */
+export async function getUserByUsername(
+ username: string,
+ columns?: (keyof User)[]
+): Promise {
+ try {
+ const [user] = await persistenceRepository.user.findRows({
+ where: eq("username", username),
+ limit: 1,
+ columns: columns ? columns : undefined,
+ });
+ return user;
+ } catch (error) {
+ handleRepositoryException(error);
+ return null;
+ }
+}
+
+/**
+ * Retrieves a user by their email.
+ *
+ * @param email - The user's email
+ * @returns Promise - The user if found, null otherwise
+ * @throws {RepositoryException} If query fails
+ */
+export async function getUserByEmail(email: string): Promise {
+ try {
+ const [user] = await persistenceRepository.user.findRows({
+ where: eq("email", email),
+ limit: 1,
+ });
+ return user;
+ } catch (error) {
+ handleRepositoryException(error);
+ return null;
+ }
+}
+
+/**
+ * Gets a paginated list of users.
+ *
+ * @param page - The page number (1-based)
+ * @param limit - Number of users per page
+ * @returns Promise<{users: User[], total: number}> - List of users and total count
+ * @throws {RepositoryException} If query fails
+ */
+export async function getUsers(page: number = 1, limit: number = 10) {
+ try {
+ return persistenceRepository.user.findAllWithPagination({
+ limit,
+ orderBy: [desc("created_at")],
+ columns: [
+ "id",
+ "name",
+ "username",
+ "email",
+ "profile_photo",
+ "created_at",
+ ],
+ });
+ } catch (error) {
+ handleRepositoryException(error);
+ return null;
+ }
+}
diff --git a/src/backend/services/user.repository.ts b/src/backend/services/user.repository.ts
new file mode 100644
index 0000000..3474cd5
--- /dev/null
+++ b/src/backend/services/user.repository.ts
@@ -0,0 +1,72 @@
+"use server";
+
+import { z } from "zod";
+import { User } from "../models/domain-models";
+import { persistenceRepository } from "../persistence-repositories";
+import { and, desc, eq } from "../persistence/persistence-where-operator";
+import { PersistentRepository } from "../persistence/persistence.repository";
+import { handleRepositoryException } from "./RepositoryException";
+import { UserRepositoryInput } from "./inputs/user.input";
+
+const userRepository = new PersistentRepository(
+ "users",
+ persistenceRepository.user
+);
+
+/**
+ * Creates or syncs a user account from a social login provider.
+ * If the user exists, links their social account. If not, creates a new user and social link.
+ *
+ * @param _input - The social user data containing service, uid and profile info, validated against UserRepositoryInput.syncSocialUserInput schema
+ * @returns Promise<{user: User, userSocial: UserSocial}> - The user and their social account link
+ * @throws {RepositoryException} If user creation/sync fails or validation fails
+ */
+export async function bootSocialUser(
+ _input: z.infer
+) {
+ try {
+ const input =
+ await UserRepositoryInput.syncSocialUserInput.parseAsync(_input);
+ let [user] = await userRepository.findRows({
+ where: eq("email", input.email),
+ columns: ["id", "name", "username", "email"],
+ orderBy: [desc("created_at")],
+ limit: 1,
+ });
+
+ if (!user) {
+ user = await userRepository.createOne({
+ name: input.name,
+ username: input.username,
+ email: input.email,
+ profile_photo: input.profile_photo,
+ bio: input.bio ?? "",
+ });
+ }
+
+ // check user has social account
+ const [userSocial] = await persistenceRepository.userSocial.findRows({
+ where: and(
+ eq("service", input.service),
+ eq("service_uid", input.service)
+ ),
+ columns: ["id", "service", "service_uid", "user_id"],
+ limit: 1,
+ });
+
+ if (!userSocial) {
+ await persistenceRepository.userSocial.createOne({
+ service: input.service,
+ service_uid: input.service_uid,
+ user_id: user.id,
+ });
+ }
+
+ return {
+ user,
+ userSocial,
+ };
+ } catch (error) {
+ handleRepositoryException(error);
+ }
+}
diff --git a/src/components/AppImage.tsx b/src/components/AppImage.tsx
index 83999c2..c1aacce 100644
--- a/src/components/AppImage.tsx
+++ b/src/components/AppImage.tsx
@@ -1,9 +1,9 @@
-import { IServerFile } from "@/http/models/AppImage.model";
import { blur } from "@cloudinary/url-gen/actions/effect";
import Image from "next/image";
import { Cloudinary } from "@cloudinary/url-gen";
import React from "react";
+import { IServerFile } from "@/backend/models/domain-models";
interface AppImageProps {
alt?: string;
diff --git a/src/components/ArticleCard.tsx b/src/components/ArticleCard.tsx
new file mode 100644
index 0000000..6dd30f6
--- /dev/null
+++ b/src/components/ArticleCard.tsx
@@ -0,0 +1,163 @@
+"use client";
+
+import { useTranslation } from "@/i18n/use-translation";
+import { formattedTime } from "@/lib/utils";
+import Link from "next/link";
+import React, { useMemo } from "react";
+import { HoverCard, HoverCardContent, HoverCardTrigger } from "./ui/hover-card";
+import UserInformationCard from "./UserInformationCard";
+
+interface ArticleCardProps {
+ id: string;
+ title: string;
+ handle: string;
+ excerpt: string;
+ coverImage?: string;
+ author: {
+ id: string;
+ name: string;
+ avatar: string;
+ username: string;
+ };
+ publishedAt: string;
+ readingTime: number;
+ likes: number;
+ comments: number;
+}
+
+const ArticleCard = ({
+ id,
+ title,
+ handle,
+ excerpt,
+ coverImage,
+ author,
+ publishedAt,
+ readingTime,
+ likes,
+ comments,
+}: ArticleCardProps) => {
+ const { lang } = useTranslation();
+
+ const articleUrl = useMemo(() => {
+ return `/${author.username}/${handle}`;
+ }, [author.username, handle]);
+
+ return (
+
+
+
+
+
+
+
+
+
+ {author.name}
+
+
+
+ ¡
+ {readingTime} min read
+
+
+
+
+
+
+
+ {title}...
+
+
+ {excerpt} [Read more]
+
+
+
+ {coverImage && (
+
+
+
+
+ )}
+
+ {/*
+
+
+
+
+
+
*/}
+
+
+
+
+
+
+ {updateMyArticleMutation.isPending ? (
+
{_t("Saving")}...
+ ) : (
+
+ {article?.updated_at && (
+
+ ({_t("Saved")} {formattedTime(article?.updated_at, lang)})
+
+ )}
+
+ )}
+
+
+ {uuid && (
+
+ {article?.is_published ? (
+ {_t("Published")}
+ ) : (
+ {_t("Draft")}
+ )}
+
+ )}
+
+
+ {uuid && (
+
+
+
+
+
+
+ )}
+
-
-
-
{_t("Write new diary đ")}
-
{_t("You will be logged out after this")}
,
+ async onConfirm() {
+ await sessionActions.deleteLoginSession();
+ window.location.reload();
+ },
+ });
+ };
+
+ return (
+
+
+
+
+ {authSession?.user?.name.charAt(0)}
+
+
+
+
+
+ {_t("My profile")}
+
+
+
+ {_t("Dashboard")}
+
+ {_t("Bookmarks")}
+ {_t("Settings")}
+
+ {_t("Logout")}
+
+
+
+ );
+};
+
+export default AuthenticatedUserMenu;
diff --git a/src/components/Navbar/LanguageSwitcher.tsx b/src/components/Navbar/LanguageSwitcher.tsx
new file mode 100644
index 0000000..ff8e720
--- /dev/null
+++ b/src/components/Navbar/LanguageSwitcher.tsx
@@ -0,0 +1,48 @@
+"use client";
+
+import { useTranslation } from "@/i18n/use-translation";
+import React from "react";
+
+const LanguageSwitcher = () => {
+ const { toggle, lang } = useTranslation();
+
+ return (
+
+ );
+};
+
+export default LanguageSwitcher;
diff --git a/src/components/Navbar/Navbar.tsx b/src/components/Navbar/Navbar.tsx
new file mode 100644
index 0000000..8fc3337
--- /dev/null
+++ b/src/components/Navbar/Navbar.tsx
@@ -0,0 +1,31 @@
+import Link from "next/link";
+import TechdiaryLogo from "../logos/TechdiaryLogo";
+
+import SearchInput from "./SearchInput";
+import NavbarActions from "./NavbarActions";
+
+interface NavbarProps {
+ Trailing?: React.ReactNode;
+}
+
+const Navbar: React.FC = async ({ Trailing }) => {
+ return (
+
+
+
+ {Trailing}
+
+
+
+ Techdiary
+
+
+
+
+
+
+
+
+
+
+
+ {authSession?.session ? (
+ <>
+
+
+
+ ) : (
+
+ )}
+
+
+
+
{_t("Login with Github")}
+
+ {/*
*/}
+
+ {/*
+
+ {_t("Login using email")}
+
+
*/}
+
-
-
-
{_t("Pick cover from unsplash")}
- setQ(e.target.value)}
- />
-
-
-
- {data?.map((image) => (
-
mutation.mutate(image.urls.regular)}
- className="relative mb-6 rounded-lg overflow-hidden group cursor-pointer"
- >
-
-
-
-
-
- ))}
-
- {isLoading &&
- Array(30)
- .fill(0)
- .map((_, i) => (
-
-
-
- ))}
-
-
-
-
-
-
-
- {user.name}
-
-
- @{user.username}
-
-
- {user?.social_links?.github && (
-
-
-
- )}
-
- {user.social_links.twitter && (
-
-
-
- )}
-
-
-
+ {/* Profile Header */}
+
+ {/* Avatar */}
+
+
+
+
+ {/* Name */}
+
+
{profileData.name}
+
kingrayhan
+
+
+
+ {/* Profile Body */}
+
+ {/* Edit Button */}
+ {session?.user?.id == userId ? (
+
+ ) : (
+
+ )}
+
+ {/* Bio */}
+
+ {profileData.bio}
+
+
+ {/* Profile Details */}
+
+ {/* Location */}
+ {profileData.location && (
+
+
{_t("Location")}
+
+ {profileData.location}
+
+
+ )}
+
+ {profileData.education && (
+
+
{_t("Education")}
+
+ {profileData.education}
+
+
+ )}
+
+
+
+
+
+ );
+};
+
+export default VisibilitySensor;
diff --git a/src/components/action.ts b/src/components/action.ts
deleted file mode 100644
index e127450..0000000
--- a/src/components/action.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-"use server";
-
-import { cookies } from "next/headers";
-
-export const logout = async () => {
- // await ssrHttp.post("api/auth/logout");
- cookies().delete("XSRF-TOKEN");
-};
diff --git a/src/components/app-alert.tsx b/src/components/app-alert.tsx
new file mode 100644
index 0000000..15f37bc
--- /dev/null
+++ b/src/components/app-alert.tsx
@@ -0,0 +1,155 @@
+"use client";
+import { CircleX } from "lucide-react";
+import React, {
+ createContext,
+ useCallback,
+ useContext,
+ useMemo,
+ useState,
+} from "react";
+import {
+ AlertDialog,
+ AlertDialogCancel,
+ AlertDialogContent,
+ AlertDialogDescription,
+ AlertDialogFooter,
+ AlertDialogHeader,
+ AlertDialogTitle,
+} from "./ui/alert-dialog";
+import { useTranslation } from "@/i18n/use-translation";
+
+interface Options {
+ title: string;
+ description?: string;
+ type?: "warning" | "error" | "success" | "info";
+ isShowCancel?: boolean;
+ isShowConfirm?: boolean;
+}
+
+interface ContextType {
+ show: (options: Options) => void;
+ closeModal: () => void;
+}
+
+const Context = createContext(undefined);
+
+export function AppAlertProvider({ children }: { children: React.ReactNode }) {
+ const { _t } = useTranslation();
+ const [modalContent, setModalContent] = useState(null);
+ const [isOpen, setIsOpen] = useState(false);
+
+ const show = useCallback((options: Options) => {
+ const type = options.type ?? "error";
+ setModalContent({
+ ...options,
+ type,
+ });
+ setIsOpen(true);
+ }, []);
+
+ const closeModal = useCallback(() => {
+ setIsOpen(false);
+ setModalContent(null);
+ }, []);
+
+ const renderIcon = useMemo(() => {
+ switch (modalContent?.type) {
+ case "error":
+ return ;
+ case "warning":
+ return (
+
+ );
+ case "success":
+ return (
+
+ );
+ case "info":
+ return (
+
+ );
+ default:
+ return null;
+ }
+ }, [modalContent?.type]);
+
+ return (
+
+ {children}
+ {modalContent && (
+
+
+
+
+ {/* {modalContent.title ?? "Are you sure?"} */}
+
+
+
+
+ {renderIcon}
+
{modalContent.title}
+ {modalContent.description && (
+
+ {modalContent?.description}
+
+ )}
+
-
-
-
-
{_t("Home")}
-
-
-
-
{_t("Bookmarks")}
-
-
-
-
{_t("New diary")}
-
-
-
-
-
-
-
-
-
-
-
- );
-};
-
-export default HomeRightSidebar;
diff --git a/src/components/asides/widgets/LatestUsers.tsx b/src/components/asides/widgets/LatestUsers.tsx
deleted file mode 100644
index 7dfdc4d..0000000
--- a/src/components/asides/widgets/LatestUsers.tsx
+++ /dev/null
@@ -1,84 +0,0 @@
-import { http } from "@/http/http.client";
-import { PaginatedResponse } from "@/http/models/PaginatedResponse.model";
-import _t from "@/i18n/_t";
-import { relativeTime } from "@/utils/relativeTime";
-// import { relativeTime } from "@/utils/relativeTime";
-import Link from "next/link";
-
-interface IUser {
- id: string;
- name: string | null;
- username: string | null;
- profilePhoto: string | null;
- social_links: {
- twitter: string | null;
- github: string | null;
- };
- joined: Date;
-}
-
-const LatestUsers = async () => {
- const { data } = await http.get>(
- "/api/profile/list"
- );
-
- return (
-
-
- {_t("Latest registered users")}
-
-
- {/* {isFetching &&
- Array.from({ length: 10 }).map((_, i) =>
)} */}
-
- {/*
{JSON.stringify(data, null, 2)} */}
- {data.data.map((user) => (
-
- ))}
-
-
-
-
-
-
-
-
-
-
-
- {user.name}
-
-
-
- {relativeTime(new Date(user.joined))}
-
-
-
-
-
-
-
-
- {currentUser?.name}
-
-
- @{currentUser?.username}
- {" "}
-
-
-
-
-
-
-
{_t("My profile")}
-
-
-
-
{_t("Dashboard")}
-
-
-
-
-
{_t("Bookmarks")}
-
-
-
-
-
-
-
-
- {_t("Login using email")}
-
-
-
+ {LeftSidebar && (
+
+ )}
+
+
+ {children}
+
+
+ {RightSidebar && (
+
+ )}
+
- {LeftSidebar && (
-
- )}
-
-
{children}
-
- {RightSidebar && (
-
- )}
-